feat: add Copilot CLI as an insights agent

- Add generateCopilot() using -p (prompt as arg), --silent,
  --no-custom-instructions, --no-ask-user, --available-tools
  (no tools) for sandboxed non-interactive execution
- Plain text output parsed from stdout (no JSON needed)
- Update ValidAgents, server validation, AgentName type, and
  agent dropdown to include copilot
- Add TestGenerateCopilot_CLIFlags and TestGenerateCopilot_EmptyResult

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: wesm

frontend/src/lib/api/types/insights.ts

@@ -19,7 +19,7 @@ export interface InsightsResponse {
   insights: Insight[];
 }
 
-export type AgentName = "claude" | "codex" | "gemini";
+export type AgentName = "claude" | "codex" | "copilot" | "gemini";
 
 export interface GenerateInsightRequest {
   type: InsightType;

frontend/src/lib/components/insights/InsightsPage.svelte

@@ -220,6 +220,7 @@
         >
           <option value="claude">Claude</option>
           <option value="codex">Codex</option>
+          <option value="copilot">Copilot</option>
           <option value="gemini">Gemini</option>
         </select>
       </div>

internal/insight/generate.go

@@ -29,9 +29,10 @@ type Result struct {
 
 // ValidAgents lists the supported agent names.
 var ValidAgents = map[string]bool{
-	"claude": true,
-	"codex":  true,
-	"gemini": true,
+	"claude":  true,
+	"codex":   true,
+	"copilot": true,
+	"gemini":  true,
 }
 
 // GenerateFunc is the signature for insight generation,
@@ -87,6 +88,8 @@ func GenerateStream(
 	switch agent {
 	case "codex":
 		return generateCodex(ctx, path, prompt, onLog)
+	case "copilot":
+		return generateCopilot(ctx, path, prompt, onLog)
 	case "gemini":
 		return generateGemini(ctx, path, prompt, onLog)
 	default:
@@ -441,6 +444,78 @@ func parseCodexStream(
 	return strings.Join(messages, "\n"), nil
 }
 
+// generateCopilot invokes `copilot -p <prompt> --silent`.
+// The prompt is passed as the -p argument (copilot does not
+// read prompts from stdin). Output is plain text on stdout.
+func generateCopilot(
+	ctx context.Context, path, prompt string, onLog LogFunc,
+) (Result, error) {
+	cmd := exec.CommandContext(
+		ctx, path,
+		"-p", prompt,
+		"--silent",
+		"--no-custom-instructions",
+		"--no-ask-user",
+		"--available-tools",
+	)
+	cmd.Dir = os.TempDir()
+	cmd.Env = cleanEnv()
+
+	stdoutPipe, err := cmd.StdoutPipe()
+	if err != nil {
+		return Result{}, fmt.Errorf(
+			"create stdout pipe: %w", err,
+		)
+	}
+	stderrPipe, err := cmd.StderrPipe()
+	if err != nil {
+		return Result{}, fmt.Errorf(
+			"create stderr pipe: %w", err,
+		)
+	}
+
+	if err := cmd.Start(); err != nil {
+		return Result{}, fmt.Errorf(
+			"start copilot: %w", err,
+		)
+	}
+
+	stderrDone := collectStreamLines(
+		stderrPipe, "stderr", onLog,
+	)
+	stdoutDone := collectStreamLines(
+		stdoutPipe, "stdout", onLog,
+	)
+
+	stdoutText := <-stdoutDone
+	stderrText := <-stderrDone
+	runErr := cmd.Wait()
+
+	if runErr != nil && ctx.Err() != nil {
+		return Result{}, fmt.Errorf(
+			"copilot CLI cancelled: %w", ctx.Err(),
+		)
+	}
+	if runErr != nil {
+		return Result{}, fmt.Errorf(
+			"copilot CLI failed: %w\nstderr: %s",
+			runErr, stderrText,
+		)
+	}
+
+	content := strings.TrimSpace(stdoutText)
+	if content == "" {
+		return Result{}, fmt.Errorf(
+			"copilot returned empty result",
+		)
+	}
+
+	return Result{
+		Content: content,
+		Agent:   "copilot",
+	}, nil
+}
+
 // generateGemini invokes `gemini --output-format stream-json`
 // and parses the JSONL stream for result/assistant messages.
 func generateGemini(

internal/insight/generate_test.go

@@ -263,7 +263,7 @@ func TestEnvKeyAllowed(t *testing.T) {
 
 func TestValidAgents(t *testing.T) {
 	for _, agent := range []string{
-		"claude", "codex", "gemini",
+		"claude", "codex", "copilot", "gemini",
 	} {
 		if !ValidAgents[agent] {
 			t.Errorf("%s should be valid", agent)
@@ -423,6 +423,79 @@ func TestGenerateCodex_CLIFlags(t *testing.T) {
 	}
 }
 
+func TestGenerateCopilot_CLIFlags(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("shell script test not supported on windows")
+	}
+
+	bin, argsFile := createMockBinary(
+		t, "Hello from copilot", 0, true, "copilot",
+	)
+
+	result, err := generateCopilot(
+		context.Background(), bin, "test prompt", nil,
+	)
+	if err != nil {
+		t.Fatalf("generateCopilot: %v", err)
+	}
+	if result.Content != "Hello from copilot" {
+		t.Errorf(
+			"Content = %q, want %q",
+			result.Content, "Hello from copilot",
+		)
+	}
+	if result.Agent != "copilot" {
+		t.Errorf("Agent = %q, want copilot", result.Agent)
+	}
+
+	argsData, err := os.ReadFile(argsFile)
+	if err != nil {
+		t.Fatalf("reading args: %v", err)
+	}
+	args := strings.Split(
+		strings.TrimSpace(string(argsData)), "\n",
+	)
+
+	wantArgs := []string{
+		"-p", "test prompt",
+		"--silent",
+		"--no-custom-instructions",
+		"--no-ask-user",
+		"--available-tools",
+	}
+	if len(args) != len(wantArgs) {
+		t.Fatalf("args = %v, want %v", args, wantArgs)
+	}
+	for i, want := range wantArgs {
+		if args[i] != want {
+			t.Errorf(
+				"arg[%d] = %q, want %q",
+				i, args[i], want,
+			)
+		}
+	}
+}
+
+func TestGenerateCopilot_EmptyResult(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("shell script test not supported on windows")
+	}
+
+	bin, _ := createMockBinary(
+		t, "", 0, false, "copilot",
+	)
+
+	_, err := generateCopilot(
+		context.Background(), bin, "test", nil,
+	)
+	if err == nil {
+		t.Fatal("expected error for empty result")
+	}
+	if !strings.Contains(err.Error(), "empty result") {
+		t.Errorf("error = %q, want empty result", err)
+	}
+}
+
 func TestGenerateClaude_SalvageOnNonZeroExit(t *testing.T) {
 	tests := []struct {
 		name       string

internal/server/insights.go

@@ -170,7 +170,7 @@ func (s *Server) handleGenerateInsight(
 	}
 	if !insight.ValidAgents[req.Agent] {
 		writeError(w, http.StatusBadRequest,
-			"invalid agent: must be claude, codex, or gemini")
+			"invalid agent: must be claude, codex, copilot, or gemini")
 		return
 	}