mcp-copilot-cli 1.0.0

package/dist/src/templates/agent-prompt.js

@@ -0,0 +1,58 @@
+import { readFile } from 'node:fs/promises';
+const ROLE_TEMPLATES = {
+    coder: [
+        'You are the implementation agent.',
+        'Work carefully, change as little as needed, and verify the requested behavior.',
+        'Prefer deterministic edits over speculative refactors.',
+    ].join(' '),
+    planner: [
+        'You are the planning agent.',
+        'Clarify scope, constraints, risks, and the concrete implementation path.',
+        'Produce actionable implementation guidance instead of vague advice.',
+    ].join(' '),
+    researcher: [
+        'You are the research agent.',
+        'Investigate the code and runtime behavior before proposing conclusions.',
+        'Surface the facts that a downstream implementer needs.',
+    ].join(' '),
+    tester: [
+        'You are the testing agent.',
+        'Exercise the real behavior, collect evidence, and describe failures concretely.',
+        'Prefer end-to-end verification when possible.',
+    ].join(' '),
+    general: [
+        'You are a general-purpose autonomous agent.',
+        'Stay focused on the requested deliverable and keep your output concrete.',
+    ].join(' '),
+};
+async function renderContextFiles(contextFiles) {
+    if (contextFiles.length === 0) {
+        return '';
+    }
+    const sections = await Promise.all(contextFiles.map(async (contextFile) => {
+        const content = await readFile(contextFile.path, 'utf8');
+        return [
+            `## Context File: ${contextFile.path}`,
+            contextFile.description ? `Description: ${contextFile.description}` : null,
+            '',
+            '```text',
+            content,
+            '```',
+        ].filter(Boolean).join('\n');
+    }));
+    return sections.join('\n\n');
+}
+export async function buildAgentPrompt(input) {
+    const context = await renderContextFiles(input.contextFiles);
+    return [
+        ROLE_TEMPLATES[input.agentType],
+        '',
+        'Treat the task as stateful background work. If you need user input, ask a concise question.',
+        '',
+        '## Assignment',
+        input.prompt,
+        context ? '' : null,
+        context || null,
+    ].filter(Boolean).join('\n');
+}
+//# sourceMappingURL=agent-prompt.js.map

package/dist/src/templates/agent-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-prompt.js","sourceRoot":"","sources":["../../../src/templates/agent-prompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAI5C,MAAM,cAAc,GAA8B;IAChD,KAAK,EAAE;QACL,mCAAmC;QACnC,gFAAgF;QAChF,wDAAwD;KACzD,CAAC,IAAI,CAAC,GAAG,CAAC;IACX,OAAO,EAAE;QACP,6BAA6B;QAC7B,0EAA0E;QAC1E,qEAAqE;KACtE,CAAC,IAAI,CAAC,GAAG,CAAC;IACX,UAAU,EAAE;QACV,6BAA6B;QAC7B,yEAAyE;QACzE,wDAAwD;KACzD,CAAC,IAAI,CAAC,GAAG,CAAC;IACX,MAAM,EAAE;QACN,4BAA4B;QAC5B,iFAAiF;QACjF,+CAA+C;KAChD,CAAC,IAAI,CAAC,GAAG,CAAC;IACX,OAAO,EAAE;QACP,6CAA6C;QAC7C,0EAA0E;KAC3E,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC;AAEF,KAAK,UAAU,kBAAkB,CAAC,YAA2B;IAC3D,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAChC,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE;QACrC,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACzD,OAAO;YACL,oBAAoB,WAAW,CAAC,IAAI,EAAE;YACtC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,gBAAgB,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI;YAC1E,EAAE;YACF,SAAS;YACT,OAAO;YACP,KAAK;SACN,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC,CAAC,CACH,CAAC;IAEF,OAAO,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC/B,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,KAItC;IACC,MAAM,OAAO,GAAG,MAAM,kBAAkB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IAE7D,OAAO;QACL,cAAc,CAAC,KAAK,CAAC,SAAS,CAAC;QAC/B,EAAE;QACF,6FAA6F;QAC7F,EAAE;QACF,eAAe;QACf,KAAK,CAAC,MAAM;QACZ,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI;QACnB,OAAO,IAAI,IAAI;KAChB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC"}

package/dist/src/types/task.d.ts

@@ -0,0 +1,79 @@
+export type AgentType = 'coder' | 'planner' | 'researcher' | 'tester' | 'general';
+export interface ContextFile {
+    path: string;
+    description?: string | undefined;
+}
+export interface PendingQuestion {
+    question: string;
+    choices?: string[] | undefined;
+    allowFreeform: boolean;
+    askedAt: string;
+    sessionId: string;
+}
+export declare enum TaskStatus {
+    PENDING = "pending",
+    WAITING = "waiting",
+    RUNNING = "running",
+    WAITING_ANSWER = "waiting_answer",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled",
+    RATE_LIMITED = "rate_limited",
+    TIMED_OUT = "timed_out"
+}
+export declare const TERMINAL_STATUSES: Set<TaskStatus>;
+export declare function isTerminalStatus(status: TaskStatus): boolean;
+export interface TaskRecord {
+    id: string;
+    status: TaskStatus;
+    prompt: string;
+    cwd: string;
+    model: string;
+    agentType: AgentType;
+    output: string[];
+    startTime: string;
+    createdAt: string;
+    updatedAt: string;
+    labels: string[];
+    contextFiles: ContextFile[];
+    dependsOn?: string[] | undefined;
+    error?: string | undefined;
+    endTime?: string | undefined;
+    outputFilePath?: string | undefined;
+    timeoutMs?: number | undefined;
+    sessionId?: string | undefined;
+    parentTaskId?: string | undefined;
+    pendingQuestion?: PendingQuestion | undefined;
+    profileId?: string | undefined;
+    profileConfigDir?: string | undefined;
+    isolationMode?: 'shared' | 'isolated' | undefined;
+    baseCwd?: string | undefined;
+}
+export interface CreateTaskInput {
+    prompt: string;
+    cwd: string;
+    model: string;
+    agentType: AgentType;
+    labels?: string[] | undefined;
+    contextFiles?: ContextFile[] | undefined;
+    dependsOn?: string[] | undefined;
+    timeoutMs?: number | undefined;
+    sessionId?: string | undefined;
+    parentTaskId?: string | undefined;
+    profileId?: string | undefined;
+    profileConfigDir?: string | undefined;
+    isolationMode?: 'shared' | 'isolated' | undefined;
+    baseCwd?: string | undefined;
+}
+export interface PersistedWorkspaceState {
+    version: 1;
+    tasks: TaskRecord[];
+    profiles: PersistedProfileState[];
+}
+export interface PersistedProfileState {
+    id: string;
+    configDir: string;
+    cooldownUntil?: number | undefined;
+    failureCount: number;
+    lastFailureReason?: string | undefined;
+}

package/dist/src/types/task.js

@@ -0,0 +1,22 @@
+export var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["PENDING"] = "pending";
+    TaskStatus["WAITING"] = "waiting";
+    TaskStatus["RUNNING"] = "running";
+    TaskStatus["WAITING_ANSWER"] = "waiting_answer";
+    TaskStatus["COMPLETED"] = "completed";
+    TaskStatus["FAILED"] = "failed";
+    TaskStatus["CANCELLED"] = "cancelled";
+    TaskStatus["RATE_LIMITED"] = "rate_limited";
+    TaskStatus["TIMED_OUT"] = "timed_out";
+})(TaskStatus || (TaskStatus = {}));
+export const TERMINAL_STATUSES = new Set([
+    TaskStatus.COMPLETED,
+    TaskStatus.FAILED,
+    TaskStatus.CANCELLED,
+    TaskStatus.TIMED_OUT,
+]);
+export function isTerminalStatus(status) {
+    return TERMINAL_STATUSES.has(status);
+}
+//# sourceMappingURL=task.js.map

package/dist/src/types/task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.js","sourceRoot":"","sources":["../../../src/types/task.ts"],"names":[],"mappings":"AAeA,MAAM,CAAN,IAAY,UAUX;AAVD,WAAY,UAAU;IACpB,iCAAmB,CAAA;IACnB,iCAAmB,CAAA;IACnB,iCAAmB,CAAA;IACnB,+CAAiC,CAAA;IACjC,qCAAuB,CAAA;IACvB,+BAAiB,CAAA;IACjB,qCAAuB,CAAA;IACvB,2CAA6B,CAAA;IAC7B,qCAAuB,CAAA;AACzB,CAAC,EAVW,UAAU,KAAV,UAAU,QAUrB;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAa;IACnD,UAAU,CAAC,SAAS;IACpB,UAAU,CAAC,MAAM;IACjB,UAAU,CAAC,SAAS;IACpB,UAAU,CAAC,SAAS;CACrB,CAAC,CAAC;AAEH,MAAM,UAAU,gBAAgB,CAAC,MAAkB;IACjD,OAAO,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "mcp-copilot-cli",
+  "version": "1.0.0",
+  "description": "Copilot-only MCP server CLI with resumable background agents",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "bin": {
+    "mcp-copilot-cli": "bin/mcp-copilot-cli.mjs"
+  },
+  "files": [
+    "bin",
+    "dist/src",
+    "src"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "dev": "tsx watch src/index.ts",
+    "serve": "node --import tsx src/index.ts",
+    "doctor": "node --import tsx src/cli/doctor.ts",
+    "prepack": "npm run build",
+    "smoke": "node --import tsx scripts/smoke.ts",
+    "test": "npm run test:unit",
+    "test:unit": "node --import tsx --test test/**/*.test.ts",
+    "test:smoke": "node --import tsx scripts/smoke.ts"
+  },
+  "keywords": [
+    "mcp",
+    "copilot",
+    "agent",
+    "sdk"
+  ],
+  "author": "Yigit Konur",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yigitkonur/mcp-copilot-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yigitkonur/mcp-copilot-cli/issues"
+  },
+  "homepage": "https://github.com/yigitkonur/mcp-copilot-cli#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "@github/copilot-sdk": "^0.1.30",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "tsx": "^4.19.2",
+    "unique-names-generator": "^4.7.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "typescript": "^5.7.2"
+  }
+}

package/src/app.ts

@@ -0,0 +1,341 @@
+import { OutputLogService } from './services/output-log.js';
+import { ProfileManager } from './services/profile-manager.js';
+import { QuestionRegistry } from './services/question-registry.js';
+import { TaskManager } from './services/task-manager.js';
+import { CopilotRuntime } from './services/copilot-runtime.js';
+import { prepareTaskWorkspace } from './services/workspace-isolation.js';
+import { DEFAULT_ISOLATION_MODE, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS } from './config/defaults.js';
+import { buildAnswerBanner, buildMessageBanner } from './mcp/tool-banners.js';
+import { createToolDefinitions, type AnswerAgentInput, type CancelAgentInput, type MessageAgentInput, type SpawnAgentInput } from './mcp/tool-definitions.js';
+import { renderTaskListMarkdown, renderTaskMarkdown } from './mcp/task-markdown.js';
+import { buildSystemStatus } from './mcp/system-status.js';
+import type { ContextFile, TaskRecord } from './types/task.js';
+import { TaskStatus } from './types/task.js';
+import { validateSpawnAgentInput } from './services/spawn-validation.js';
+
+export class CopilotMcpApp {
+  readonly outputLog = new OutputLogService();
+  readonly profileManager = ProfileManager.fromEnvironment();
+  readonly taskManager = new TaskManager({
+    outputLog: this.outputLog,
+    getProfiles: () => this.profileManager.toPersistedState(),
+  });
+  readonly questionRegistry = new QuestionRegistry(this.taskManager);
+  readonly runtime = new CopilotRuntime({
+    taskManager: this.taskManager,
+    profileManager: this.profileManager,
+    questionRegistry: this.questionRegistry,
+  });
+
+  async initialize(cwd: string): Promise<void> {
+    const restored = await this.taskManager.load(cwd);
+    this.profileManager.hydrate(restored.profiles);
+  }
+
+  listTools() {
+    return createToolDefinitions({
+      messageBanner: buildMessageBanner(this.taskManager),
+      answerBanner: buildAnswerBanner(this.questionRegistry),
+    });
+  }
+
+  async spawnAgent(input: SpawnAgentInput): Promise<string> {
+    const baseCwd = input.cwd ?? process.cwd();
+    const validated = await validateSpawnAgentInput({ input, baseCwd });
+    const isolationMode = input.isolation_mode ?? DEFAULT_ISOLATION_MODE;
+    const workspace = await prepareTaskWorkspace({
+      baseCwd,
+      taskId: `${Date.now().toString(36)}-workspace`,
+      isolationMode,
+    });
+
+    const task = await this.taskManager.createTask({
+      prompt: input.prompt,
+      cwd: workspace.cwd,
+      baseCwd,
+      model: input.model ?? DEFAULT_MODEL,
+      agentType: input.agent_type,
+      labels: input.labels,
+      contextFiles: validated.contextFiles,
+      dependsOn: input.depends_on,
+      timeoutMs: input.timeout ?? DEFAULT_TIMEOUT_MS,
+      isolationMode,
+    });
+
+    if (task.status === TaskStatus.WAITING) {
+      return [
+        '✅ **Task queued (waiting for dependencies)**',
+        `task_id: \`${task.id}\``,
+        task.outputFilePath ? `output_file: \`${task.outputFilePath}\`` : null,
+        '',
+        '**Monitor:** Read `task:///all` — shows all tasks with status and pending questions in one table.',
+      ].filter(Boolean).join('\n');
+    }
+
+    void this.startTask(task.id).catch(() => {});
+
+    return [
+      '✅ **Task launched**',
+      `task_id: \`${task.id}\``,
+      task.outputFilePath ? `read logs: \`cat -n ${task.outputFilePath}\`` : null,
+      task.outputFilePath ? 'Use `cat -n` to read with line numbers, then on subsequent reads use `tail -n +<N>` to skip already-read lines.' : null,
+      '',
+      '**What to do next:**',
+      '- If you still have more agents to launch, launch them now — all agents run in parallel.',
+      '- Once all agents are launched, run `sleep 30` and then check status.',
+      `- To check status, read the MCP resource \`task:///${task.id}\` — it will show current progress, output, and whether the agent needs input.`,
+      task.outputFilePath ? `- For a quick progress check without reading the full resource, run \`wc -l ${task.outputFilePath}\` — a growing line count means the agent is still working.` : null,
+    ].filter(Boolean).join('\n');
+  }
+
+  async messageAgent(input: MessageAgentInput): Promise<string> {
+    const original = this.taskManager.getTask(input.task_id);
+    if (!original) {
+      throw new Error(`Task not found: ${input.task_id}`);
+    }
+    if (!original.sessionId) {
+      throw new Error(`Task ${input.task_id} has no resumable session`);
+    }
+
+    const task = await this.taskManager.createTask({
+      prompt: input.message ?? 'continue',
+      cwd: input.cwd ?? original.cwd,
+      baseCwd: input.cwd ?? original.baseCwd ?? original.cwd,
+      model: original.model,
+      agentType: original.agentType,
+      labels: [...original.labels, `continued-from:${original.id}`],
+      contextFiles: original.contextFiles,
+      timeoutMs: input.timeout ?? original.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      sessionId: original.sessionId,
+      parentTaskId: original.id,
+      profileId: original.profileId,
+      profileConfigDir: original.profileConfigDir,
+      isolationMode: original.isolationMode,
+    });
+
+    void this.startTask(task.id).catch(() => {});
+
+    return [
+      '✅ **Message sent**',
+      `task_id: \`${task.id}\``,
+      '',
+      task.outputFilePath ? `read logs: \`cat -n ${task.outputFilePath}\`` : null,
+      task.outputFilePath ? 'Use `cat -n` to read with line numbers, then on subsequent reads use `tail -n +<N>` to skip already-read lines.' : null,
+    ].filter(Boolean).join('\n');
+  }
+
+  async cancelAgent(input: CancelAgentInput): Promise<string> {
+    if (input.task_id === 'all') {
+      if (!input.clear || !input.confirm) {
+        throw new Error('Use clear=true and confirm=true with task_id="all"');
+      }
+
+      const count = await this.taskManager.clearAllTasks();
+      return `✅ Cleared **${count}** tasks from workspace.`;
+    }
+
+    const taskIds = Array.isArray(input.task_id) ? input.task_id : [input.task_id];
+    const results = await Promise.all(taskIds.map((taskId) => this.taskManager.cancelTask(taskId)));
+    return `✅ Cancelled ${results.filter(Boolean).length}/${taskIds.length} task(s).`;
+  }
+
+  async answerAgent(input: AnswerAgentInput): Promise<string> {
+    const rawAnswer = input.answer ?? Object.values(input.answers ?? {})[0];
+    if (!rawAnswer) {
+      throw new Error('Provide answer or answers');
+    }
+
+    const result = this.questionRegistry.submitAnswer(input.task_id, rawAnswer);
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+
+    return [
+      '✅ **Answer submitted**',
+      `task_id: \`${input.task_id}\``,
+      `**Answer:** ${result.resolvedAnswer}`,
+    ].join('\n');
+  }
+
+  listResources() {
+    return [
+      {
+        uri: 'system:///status',
+        name: 'System Status',
+        description: 'Current task and profile counts',
+        mimeType: 'application/json',
+      },
+      {
+        uri: 'task:///all',
+        name: 'All Tasks',
+        description: `${this.taskManager.getAllTasks().length} tracked tasks`,
+        mimeType: 'text/markdown',
+      },
+      ...this.taskManager.getAllTasks().flatMap((task) => ([
+        {
+          uri: `task:///${task.id}`,
+          name: task.id,
+          description: task.status,
+          mimeType: 'text/markdown',
+        },
+        {
+          uri: `task:///${task.id}/session`,
+          name: `${task.id} session`,
+          description: `Execution log for ${task.id}`,
+          mimeType: 'application/json',
+        },
+      ])),
+    ];
+  }
+
+  async readResource(uri: string): Promise<{ mimeType: string; text: string }> {
+    if (uri === 'system:///status') {
+      return {
+        mimeType: 'application/json',
+        text: JSON.stringify(
+          buildSystemStatus({
+            tasks: this.taskManager.getAllTasks(),
+            profiles: this.profileManager.getProfiles(),
+          }),
+          null,
+          2,
+        ),
+      };
+    }
+
+    if (uri === 'task:///all') {
+      return {
+        mimeType: 'text/markdown',
+        text: renderTaskListMarkdown(this.taskManager.getAllTasks()),
+      };
+    }
+
+    if (uri.startsWith('task:///') && uri.endsWith('/session')) {
+      const taskId = uri.slice('task:///'.length, -'/session'.length);
+      const task = this.getTaskOrThrow(taskId);
+      return {
+        mimeType: 'application/json',
+        text: JSON.stringify({
+          taskId: task.id,
+          status: task.status,
+          output: task.output,
+        }),
+      };
+    }
+
+    if (uri.startsWith('task:///')) {
+      const taskId = uri.slice('task:///'.length);
+      const task = this.getTaskOrThrow(taskId);
+      return {
+        mimeType: 'text/markdown',
+        text: renderTaskMarkdown(task),
+      };
+    }
+
+    throw new Error(`Unknown resource URI: ${uri}`);
+  }
+
+  async shutdown(): Promise<void> {
+    await this.runtime.shutdown();
+  }
+
+  listTaskSummaries() {
+    return this.taskManager.getAllTasks().map((task) => this.toMcpTask(task));
+  }
+
+  getTaskSummary(taskId: string) {
+    return this.toMcpTask(this.getTaskOrThrow(taskId));
+  }
+
+  getTaskPayload(taskId: string) {
+    const task = this.getTaskOrThrow(taskId);
+    return {
+      taskId: task.id,
+      status: task.status,
+      output: task.output,
+      error: task.error,
+      outputFilePath: task.outputFilePath,
+      pendingQuestion: task.pendingQuestion,
+    };
+  }
+
+  async cancelTaskById(taskId: string) {
+    const cancelled = await this.taskManager.cancelTask(taskId);
+    if (!cancelled && !this.taskManager.getTask(taskId)) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    return this.getTaskSummary(taskId);
+  }
+
+  private async startTask(taskId: string): Promise<void> {
+    const task = this.taskManager.getTask(taskId);
+    if (!task) {
+      return;
+    }
+
+    try {
+      await this.runtime.runTask(task);
+      const ready = await this.taskManager.releaseReadyTasks();
+      await Promise.all(ready.map((released) => this.startTask(released.id)));
+    } catch (error) {
+      await this.taskManager.updateTask(taskId, {
+        status: TaskStatus.FAILED,
+        error: error instanceof Error ? error.message : String(error),
+        endTime: new Date().toISOString(),
+      }).catch(() => {});
+    }
+  }
+
+  private getTaskOrThrow(taskId: string) {
+    const task = this.taskManager.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    return task;
+  }
+
+  private toMcpTask(task: TaskRecord) {
+    return {
+      taskId: task.id,
+      status: this.toMcpTaskStatus(task.status),
+      statusMessage: this.buildTaskStatusMessage(task),
+      createdAt: task.createdAt,
+      lastUpdatedAt: task.updatedAt,
+      ttl: task.timeoutMs ?? null,
+      pollInterval: 2_000,
+    };
+  }
+
+  private toMcpTaskStatus(status: TaskStatus): 'working' | 'input_required' | 'completed' | 'failed' | 'cancelled' {
+    switch (status) {
+      case TaskStatus.WAITING_ANSWER:
+        return 'input_required';
+      case TaskStatus.COMPLETED:
+        return 'completed';
+      case TaskStatus.CANCELLED:
+        return 'cancelled';
+      case TaskStatus.FAILED:
+      case TaskStatus.TIMED_OUT:
+      case TaskStatus.RATE_LIMITED:
+        return 'failed';
+      default:
+        return 'working';
+    }
+  }
+
+  private buildTaskStatusMessage(task: TaskRecord): string | undefined {
+    if (task.pendingQuestion?.question) {
+      return task.pendingQuestion.question;
+    }
+    if (task.status === TaskStatus.WAITING && (task.dependsOn?.length ?? 0) > 0) {
+      return `Waiting for dependencies: ${(task.dependsOn ?? []).join(', ')}`;
+    }
+    if (task.error) {
+      return task.error;
+    }
+    if (task.status === TaskStatus.COMPLETED) {
+      return 'Task completed';
+    }
+    return undefined;
+  }
+}

package/src/cli/doctor.ts

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import { execFile } from 'node:child_process';
+import process from 'node:process';
+import { promisify } from 'node:util';
+
+import { CopilotClient } from '@github/copilot-sdk';
+
+import { buildCopilotClientOptions } from '../services/copilot-runtime.js';
+import { ProfileManager } from '../services/profile-manager.js';
+
+const execFileAsync = promisify(execFile);
+
+async function commandVersion(command: string, args: string[] = ['--version']): Promise<string | null> {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, args, { encoding: 'utf8' });
+    return (stdout || stderr).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function inspectProfiles() {
+  const profileManager = ProfileManager.fromEnvironment();
+  const profiles = profileManager.getProfiles();
+
+  return Promise.all(
+    profiles.map(async (profile) => {
+      const client = new CopilotClient(
+        buildCopilotClientOptions({ cwd: process.cwd(), profile }),
+      );
+
+      try {
+        await client.start();
+        const auth = await client.getAuthStatus();
+        const models = auth.isAuthenticated
+          ? await client.listModels().catch(() => [])
+          : [];
+
+        return {
+          id: profile.id,
+          configDir: profile.configDir,
+          authenticated: auth.isAuthenticated,
+          login: auth.login,
+          models: models.slice(0, 10).map((model) => model.id),
+        };
+      } catch (error) {
+        return {
+          id: profile.id,
+          configDir: profile.configDir,
+          authenticated: false,
+          error: error instanceof Error ? error.message : String(error),
+          models: [],
+        };
+      } finally {
+        await client.stop().catch(async () => {
+          await client.forceStop().catch(() => {});
+        });
+      }
+    }),
+  );
+}
+
+async function main(): Promise<void> {
+  const json = process.argv.includes('--json');
+  const inspectedProfiles = await inspectProfiles();
+  const report = {
+    node: process.version,
+    copilot: await commandVersion('copilot'),
+    mcpc: await commandVersion('mcpc'),
+    cwd: process.cwd(),
+    copilotCliPath: buildCopilotClientOptions({
+      cwd: process.cwd(),
+      profile: {
+        id: 'doctor',
+        configDir: process.env.COPILOT_CONFIG_DIRS?.split(',')[0]?.trim() || `${process.env.HOME}/.copilot`,
+        failureCount: 0,
+      },
+    }).cliPath,
+    profiles: inspectedProfiles,
+  };
+
+  if (json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(`Node: ${report.node}\n`);
+  process.stdout.write(`Copilot CLI: ${report.copilot ?? 'not found'}\n`);
+  process.stdout.write(`Copilot CLI Path: ${report.copilotCliPath}\n`);
+  process.stdout.write(`mcpc: ${report.mcpc ?? 'not found'}\n`);
+  process.stdout.write(`cwd: ${report.cwd}\n`);
+  process.stdout.write('\nProfiles:\n');
+  for (const profile of report.profiles) {
+    process.stdout.write(`- ${profile.id} (${profile.configDir}) authenticated=${String(profile.authenticated)}`);
+    if ('login' in profile && profile.login) {
+      process.stdout.write(` login=${profile.login}`);
+    }
+    if ('error' in profile && profile.error) {
+      process.stdout.write(` error=${profile.error}`);
+    }
+    process.stdout.write('\n');
+    if (profile.models.length > 0) {
+      process.stdout.write(`  models: ${profile.models.join(', ')}\n`);
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/config/defaults.ts

@@ -0,0 +1,3 @@
+export const DEFAULT_MODEL = 'gpt-5.4';
+export const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+export const DEFAULT_ISOLATION_MODE = 'isolated';