feat(issue): add get_discussion_markdown to issue_read

Adds a new issue_read method that fetches an issue and its comments
and renders them as a single Markdown document, instead of a JSON
array. Formatting logic lives in a pure, unit-tested helper
(formatDiscussionMarkdown) covering comment rendering, empty comment
lists, and attachment-inlined bodies. Existing get/get_comments/
get_labels methods are unchanged.

Co-Authored-By: Codet <codet@commitgo.dev> (GPT-5-Codex)

operation/actions/runs.go

@@ -29,7 +29,7 @@ var (
 		ActionsRunReadToolName,
 		"Read Actions workflows, runs, jobs, logs, and artifacts.",
 		annotation.ReadOnly("Read Actions workflow, run, job, and artifact data"),
-		tool.String("method", tool.Required(), tool.Enum("list_workflows", "get_workflow", "list_runs", "get_run", "list_jobs", "list_run_jobs", "get_job", "get_job_log_preview", "download_job_log", "list_artifacts", "list_run_artifacts", "get_artifact", "download_artifact", "wait_for_pr_checks")),
+		tool.String("method", tool.Required(), tool.Enum("list_workflows", "get_workflow", "list_runs", "get_run", "list_jobs", "list_run_jobs", "get_job", "get_job_log_preview", "download_job_log", "list_artifacts", "list_run_artifacts", "get_artifact", "download_artifact")),
 		tool.String("owner", tool.Required(), tool.Description(params.OwnerDesc)),
 		tool.String("repo", tool.Required(), tool.Description(params.RepoDesc)),
 		tool.String("workflow_id", tool.Description("ID or filename (for 'get_workflow')")),
@@ -43,9 +43,6 @@ var (
 		tool.String("output_path", tool.Description("for 'download_job_log'/'download_artifact'")),
 		tool.Number("page", tool.Description(params.PageDesc), tool.Default(1), tool.Minimum(1)),
 		tool.Number("per_page", tool.Description(params.PaginationDesc), tool.Default(30), tool.Minimum(1)),
-		tool.Number("pull_number", tool.Description("PR number (for 'wait_for_pr_checks')")),
-		tool.Number("timeout_seconds", tool.Description("max time to wait (for 'wait_for_pr_checks')"), tool.Default(120), tool.Minimum(1)),
-		tool.Number("poll_interval_seconds", tool.Description("time between polls (for 'wait_for_pr_checks')"), tool.Default(5), tool.Minimum(1)),
 	)
 
 	ActionsRunWriteTool = tool.NewDefinition(
@@ -99,8 +96,6 @@ func runReadFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, e
 		return getRepoActionArtifactFn(ctx, args)
 	case "download_artifact":
 		return downloadRepoActionArtifactFn(ctx, args)
-	case "wait_for_pr_checks":
-		return waitForPRChecksFn(ctx, args)
 	default:
 		return to.ErrorResult(fmt.Errorf("unknown method: %s", method))
 	}

operation/actions/wait.go

@@ -1,174 +0,0 @@
-package actions
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/url"
-	"strings"
-	"time"
-
-	"gitea.com/gitea/gitea-mcp/pkg/params"
-	"gitea.com/gitea/gitea-mcp/pkg/to"
-
-	"github.com/modelcontextprotocol/go-sdk/mcp"
-)
-
-const (
-	defaultWaitForPRChecksTimeoutSeconds      = 120
-	defaultWaitForPRChecksPollIntervalSeconds = 5
-)
-
-// terminalRunStatuses lists Gitea Actions run statuses that never transition
-// further, independent of whether a "conclusion" field is also present.
-var terminalRunStatuses = map[string]bool{
-	"completed": true,
-	"success":   true,
-	"failure":   true,
-	"cancelled": true,
-	"skipped":   true,
-	"failed":    true,
-	"error":     true,
-}
-
-func isRunTerminal(run map[string]any) bool {
-	if conclusion, ok := run["conclusion"].(string); ok && conclusion != "" {
-		return true
-	}
-	status, _ := run["status"].(string)
-	return terminalRunStatuses[strings.ToLower(status)]
-}
-
-func allRunsTerminal(runs []map[string]any) bool {
-	for _, run := range runs {
-		if !isRunTerminal(run) {
-			return false
-		}
-	}
-	return true
-}
-
-// waitForRunsUntilTerminal polls fetch until every run it returns is terminal
-// or timeout elapses, sleeping pollInterval (capped to the remaining time)
-// between polls so callers can inject a short pollInterval in tests.
-func waitForRunsUntilTerminal(ctx context.Context, timeout, pollInterval time.Duration, fetch func(ctx context.Context) ([]map[string]any, error)) ([]map[string]any, bool, error) {
-	deadline := time.Now().Add(timeout)
-	for {
-		runs, err := fetch(ctx)
-		if err != nil {
-			return nil, false, err
-		}
-		if allRunsTerminal(runs) {
-			return runs, false, nil
-		}
-
-		remaining := time.Until(deadline)
-		if remaining <= 0 {
-			return runs, true, nil
-		}
-		wait := min(pollInterval, remaining)
-
-		select {
-		case <-ctx.Done():
-			return runs, false, ctx.Err()
-		case <-time.After(wait):
-		}
-	}
-}
-
-func fetchPullRequestHeadSHA(ctx context.Context, owner, repo string, pullNumber int64) (string, error) {
-	var result map[string]any
-	err := doJSONWithFallback(ctx, "GET",
-		[]string{
-			fmt.Sprintf("repos/%s/%s/pulls/%d", url.PathEscape(owner), url.PathEscape(repo), pullNumber),
-		},
-		nil, nil, &result,
-	)
-	if err != nil {
-		return "", err
-	}
-	head, ok := result["head"].(map[string]any)
-	if !ok {
-		return "", errors.New("pull request response missing head")
-	}
-	sha, ok := head["sha"].(string)
-	if !ok || sha == "" {
-		return "", errors.New("pull request response missing head.sha")
-	}
-	return sha, nil
-}
-
-func fetchActionRunsForSHA(ctx context.Context, owner, repo, sha string) ([]map[string]any, error) {
-	query := url.Values{}
-	query.Set("head_sha", sha)
-
-	var result map[string]any
-	err := doJSONWithFallback(ctx, "GET",
-		[]string{
-			fmt.Sprintf("repos/%s/%s/actions/runs", url.PathEscape(owner), url.PathEscape(repo)),
-		},
-		query, nil, &result,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	items, _ := result["workflow_runs"].([]any)
-	runs := make([]map[string]any, 0, len(items))
-	for _, item := range items {
-		if run, ok := item.(map[string]any); ok {
-			runs = append(runs, run)
-		}
-	}
-	return runs, nil
-}
-
-func waitForPRChecksFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	owner, err := params.GetString(args, "owner")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	repo, err := params.GetString(args, "repo")
-	if err != nil {
-		return to.ErrorResult(err)
-	}
-	pullNumber, err := params.GetIndex(args, "pull_number")
-	if err != nil || pullNumber <= 0 {
-		return to.ErrorResult(errors.New("pull_number is required"))
-	}
-
-	timeoutSeconds := params.GetOptionalInt(args, "timeout_seconds", defaultWaitForPRChecksTimeoutSeconds)
-	if timeoutSeconds <= 0 {
-		timeoutSeconds = defaultWaitForPRChecksTimeoutSeconds
-	}
-	pollIntervalSeconds := params.GetOptionalInt(args, "poll_interval_seconds", defaultWaitForPRChecksPollIntervalSeconds)
-	if pollIntervalSeconds <= 0 {
-		pollIntervalSeconds = defaultWaitForPRChecksPollIntervalSeconds
-	}
-
-	sha, err := fetchPullRequestHeadSHA(ctx, owner, repo, pullNumber)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("get pull request err: %v", err))
-	}
-
-	runs, timedOut, err := waitForRunsUntilTerminal(ctx,
-		time.Duration(timeoutSeconds)*time.Second,
-		time.Duration(pollIntervalSeconds)*time.Second,
-		func(ctx context.Context) ([]map[string]any, error) {
-			return fetchActionRunsForSHA(ctx, owner, repo, sha)
-		},
-	)
-	if err != nil {
-		return to.ErrorResult(fmt.Errorf("wait for pr checks err: %v", err))
-	}
-
-	slimmedRuns := make([]map[string]any, 0, len(runs))
-	for _, run := range runs {
-		slimmedRuns = append(slimmedRuns, slimRun(run))
-	}
-	return to.TextResult(map[string]any{
-		"head_sha":  sha,
-		"timed_out": timedOut,
-		"runs":      slimmedRuns,
-	})
-}

operation/actions/wait_test.go

@@ -1,169 +0,0 @@
-package actions
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"gitea.com/gitea/gitea-mcp/pkg/flag"
-
-	"github.com/modelcontextprotocol/go-sdk/mcp"
-)
-
-func TestAllRunsTerminal(t *testing.T) {
-	tests := []struct {
-		name string
-		runs []map[string]any
-		want bool
-	}{
-		{"no runs", nil, true},
-		{"single completed run with conclusion", []map[string]any{{"status": "completed", "conclusion": "success"}}, true},
-		{"single running run", []map[string]any{{"status": "running", "conclusion": ""}}, false},
-		{"single waiting run", []map[string]any{{"status": "waiting"}}, false},
-		{"mixed terminal and running", []map[string]any{
-			{"status": "completed", "conclusion": "success"},
-			{"status": "running"},
-		}, false},
-		{"all terminal", []map[string]any{
-			{"status": "completed", "conclusion": "failure"},
-			{"status": "completed", "conclusion": "cancelled"},
-		}, true},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := allRunsTerminal(tt.runs); got != tt.want {
-				t.Errorf("allRunsTerminal() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestWaitForRunsUntilTerminal_ReturnsOnceTerminal(t *testing.T) {
-	calls := 0
-	fetch := func(ctx context.Context) ([]map[string]any, error) {
-		calls++
-		if calls < 3 {
-			return []map[string]any{{"status": "running"}}, nil
-		}
-		return []map[string]any{{"status": "completed", "conclusion": "success"}}, nil
-	}
-
-	runs, timedOut, err := waitForRunsUntilTerminal(context.Background(), time.Second, time.Millisecond, fetch)
-	if err != nil {
-		t.Fatalf("waitForRunsUntilTerminal() error = %v", err)
-	}
-	if timedOut {
-		t.Fatalf("expected timedOut = false")
-	}
-	if calls != 3 {
-		t.Fatalf("expected 3 fetch calls, got %d", calls)
-	}
-	if len(runs) != 1 || runs[0]["conclusion"] != "success" {
-		t.Fatalf("unexpected runs: %v", runs)
-	}
-}
-
-func TestWaitForRunsUntilTerminal_TimesOut(t *testing.T) {
-	fetch := func(ctx context.Context) ([]map[string]any, error) {
-		return []map[string]any{{"status": "running"}}, nil
-	}
-
-	runs, timedOut, err := waitForRunsUntilTerminal(context.Background(), 20*time.Millisecond, time.Millisecond, fetch)
-	if err != nil {
-		t.Fatalf("waitForRunsUntilTerminal() error = %v", err)
-	}
-	if !timedOut {
-		t.Fatalf("expected timedOut = true")
-	}
-	if len(runs) != 1 {
-		t.Fatalf("expected last fetched runs to be returned, got %v", runs)
-	}
-}
-
-func TestWaitForRunsUntilTerminal_PropagatesFetchError(t *testing.T) {
-	wantErr := errors.New("boom")
-	fetch := func(ctx context.Context) ([]map[string]any, error) {
-		return nil, wantErr
-	}
-
-	_, _, err := waitForRunsUntilTerminal(context.Background(), time.Second, time.Millisecond, fetch)
-	if !errors.Is(err, wantErr) {
-		t.Fatalf("waitForRunsUntilTerminal() error = %v, want %v", err, wantErr)
-	}
-}
-
-func Test_waitForPRChecksFn(t *testing.T) {
-	const (
-		owner      = "octo"
-		repo       = "demo"
-		pullNumber = 42
-		headSHA    = "abc123"
-	)
-
-	var runsRequests int32
-
-	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		switch {
-		case r.URL.Path == fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d", owner, repo, pullNumber):
-			_, _ = fmt.Fprintf(w, `{"head":{"sha":%q}}`, headSHA)
-		case r.URL.Path == fmt.Sprintf("/api/v1/repos/%s/%s/actions/runs", owner, repo):
-			atomic.AddInt32(&runsRequests, 1)
-			if r.URL.Query().Get("head_sha") != headSHA {
-				t.Errorf("expected head_sha query param %q, got %q", headSHA, r.URL.Query().Get("head_sha"))
-			}
-			_, _ = fmt.Fprint(w, `{"workflow_runs":[{"id":1,"status":"completed","conclusion":"success"},{"id":2,"status":"completed","conclusion":"failure"}]}`)
-		default:
-			http.NotFound(w, r)
-		}
-	})
-
-	server := httptest.NewServer(handler)
-	defer server.Close()
-
-	var mu sync.Mutex
-	mu.Lock()
-	origHost, origToken := flag.Host, flag.Token
-	flag.Host, flag.Token = server.URL, ""
-	mu.Unlock()
-	defer func() {
-		mu.Lock()
-		flag.Host, flag.Token = origHost, origToken
-		mu.Unlock()
-	}()
-
-	args := map[string]any{
-		"owner":       owner,
-		"repo":        repo,
-		"pull_number": float64(pullNumber),
-	}
-
-	result, err := waitForPRChecksFn(context.Background(), args)
-	if err != nil {
-		t.Fatalf("waitForPRChecksFn() error = %v", err)
-	}
-	if atomic.LoadInt32(&runsRequests) != 1 {
-		t.Fatalf("expected exactly 1 runs request, got %d", runsRequests)
-	}
-
-	if len(result.Content) == 0 {
-		t.Fatalf("expected content in result")
-	}
-	textContent, ok := result.Content[0].(*mcp.TextContent)
-	if !ok {
-		t.Fatalf("expected text content, got %T", result.Content[0])
-	}
-	if !strings.Contains(textContent.Text, headSHA) {
-		t.Fatalf("expected result to mention head sha %q, got %s", headSHA, textContent.Text)
-	}
-	if !strings.Contains(textContent.Text, `"timed_out":false`) {
-		t.Fatalf("expected result to report timed_out=false, got %s", textContent.Text)
-	}
-}

operation/issue/issue.go

@@ -55,9 +55,9 @@ var (
 
 	IssueReadTool = tool.NewDefinition(
 		IssueReadToolName,
-		"Read issue: details, comments, or labels.",
+		"Read issue: details, comments, labels, or the full discussion as Markdown.",
 		annotation.ReadOnly("Read issue details"),
-		tool.String("method", tool.Required(), tool.Enum("get", "get_comments", "get_labels")),
+		tool.String("method", tool.Required(), tool.Enum("get", "get_comments", "get_labels", "get_discussion_markdown")),
 		tool.String("owner", tool.Required(), tool.Description(params.OwnerDesc)),
 		tool.String("repo", tool.Required(), tool.Description(params.RepoDesc)),
 		tool.Number("issue_number", tool.Required()),
@@ -112,6 +112,8 @@ func issueReadFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult,
 		return getIssueCommentsByIndexFn(ctx, args)
 	case "get_labels":
 		return getIssueLabelsFn(ctx, args)
+	case "get_discussion_markdown":
+		return getIssueDiscussionMarkdownFn(ctx, args)
 	default:
 		return to.ErrorResult(fmt.Errorf("unknown method: %s", method))
 	}
@@ -398,6 +400,54 @@ func getIssueCommentsByIndexFn(ctx context.Context, args map[string]any) (*mcp.C
 	return to.TextResult(out)
 }
 
+func getIssueDiscussionMarkdownFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	index, err := params.GetIndex(args, "issue_number")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+
+	var issue issueWithAssets
+	issuePath := fmt.Sprintf("repos/%s/%s/issues/%d", url.PathEscape(owner), url.PathEscape(repo), index)
+	if _, err := gitea.DoJSON(ctx, "GET", issuePath, nil, nil, &issue); err != nil {
+		return to.ErrorResult(fmt.Errorf("get %v/%v/issue/%v err: %v", owner, repo, index, err))
+	}
+
+	var comments []commentWithAssets
+	commentsPath := fmt.Sprintf("repos/%s/%s/issues/%d/comments", url.PathEscape(owner), url.PathEscape(repo), index)
+	if _, err := gitea.DoJSON(ctx, "GET", commentsPath, nil, nil, &comments); err != nil {
+		return to.ErrorResult(fmt.Errorf("get %v/%v/issues/%v/comments err: %v", owner, repo, index, err))
+	}
+
+	discComments := make([]discussionComment, 0, len(comments))
+	for i := range comments {
+		discComments = append(discComments, discussionComment{
+			Author:    slim.UserLogin(comments[i].Poster),
+			CreatedAt: comments[i].Created,
+			Body:      slim.BodyWithAttachments(comments[i].Body, comments[i].Assets),
+		})
+	}
+
+	md := formatDiscussionMarkdown(discussionIssue{
+		Number:    issue.Index,
+		Title:     issue.Title,
+		Author:    slim.UserLogin(issue.Poster),
+		State:     string(issue.State),
+		Labels:    slim.LabelNames(issue.Labels),
+		Body:      slim.BodyWithAttachments(issue.Body, issue.Assets),
+		CreatedAt: issue.Created,
+	}, discComments)
+
+	return to.RawTextResult(md)
+}
+
 func getIssueLabelsFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
 	owner, err := params.GetString(args, "owner")
 	if err != nil {

operation/issue/issue_test.go

@@ -266,6 +266,119 @@ func Test_getIssueByIndexFn_includesAttachments(t *testing.T) {
 	}
 }
 
+func Test_getIssueDiscussionMarkdownFn(t *testing.T) {
+	const (
+		owner = "octo"
+		repo  = "demo"
+	)
+
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v1/version":
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"version":"1.12.0"}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/42", owner, repo):
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{
+				"number": 42,
+				"title": "bug with screenshot",
+				"body": "see attached",
+				"state": "open",
+				"user": {"login": "octocat"},
+				"labels": [{"name": "bug"}],
+				"created_at": "2026-01-02T15:04:05Z",
+				"assets": [
+					{"id": 1, "name": "shot.png", "size": 1024, "browser_download_url": "https://example/shot.png"}
+				]
+			}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/42/comments", owner, repo):
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`[
+				{"id": 1, "body": "see this", "user": {"login": "reviewer"}, "created_at": "2026-01-03T09:00:00Z", "assets": [
+					{"id": 9, "name": "log.txt", "size": 200, "browser_download_url": "https://example/log.txt"}
+				]}
+			]`))
+		default:
+			http.NotFound(w, r)
+		}
+	})
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	origHost, origToken, origVersion := flag.Host, flag.Token, flag.Version
+	flag.Host, flag.Token, flag.Version = server.URL, "", "test"
+	defer func() { flag.Host, flag.Token, flag.Version = origHost, origToken, origVersion }()
+
+	args := map[string]any{
+		"owner": owner, "repo": repo, "issue_number": float64(42),
+	}
+	res, err := getIssueDiscussionMarkdownFn(context.Background(), args)
+	if err != nil {
+		t.Fatalf("getIssueDiscussionMarkdownFn() error = %v", err)
+	}
+	if res.IsError {
+		t.Fatalf("unexpected error result: %v", res.Content)
+	}
+	body := res.Content[0].(*mcp.TextContent).Text
+	for _, want := range []string{
+		"# bug with screenshot (#42)",
+		"**Author:** octocat",
+		"**State:** open",
+		"**Labels:** bug",
+		"[shot.png](https://example/shot.png)",
+		"### reviewer on 2026-01-03T09:00:00Z",
+		"[log.txt](https://example/log.txt)",
+	} {
+		if !strings.Contains(body, want) {
+			t.Fatalf("expected markdown to contain %q, got:\n%s", want, body)
+		}
+	}
+}
+
+func Test_getIssueDiscussionMarkdownFn_noComments(t *testing.T) {
+	const (
+		owner = "octo"
+		repo  = "demo"
+	)
+
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v1/version":
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"version":"1.12.0"}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/7", owner, repo):
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"number": 7, "title": "quiet issue", "state": "open", "user": {"login": "octocat"}}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/7/comments", owner, repo):
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`[]`))
+		default:
+			http.NotFound(w, r)
+		}
+	})
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	origHost, origToken, origVersion := flag.Host, flag.Token, flag.Version
+	flag.Host, flag.Token, flag.Version = server.URL, "", "test"
+	defer func() { flag.Host, flag.Token, flag.Version = origHost, origToken, origVersion }()
+
+	args := map[string]any{
+		"owner": owner, "repo": repo, "issue_number": float64(7),
+	}
+	res, err := getIssueDiscussionMarkdownFn(context.Background(), args)
+	if err != nil {
+		t.Fatalf("getIssueDiscussionMarkdownFn() error = %v", err)
+	}
+	if res.IsError {
+		t.Fatalf("unexpected error result: %v", res.Content)
+	}
+	body := res.Content[0].(*mcp.TextContent).Text
+	if !strings.Contains(body, "_No comments yet._") {
+		t.Fatalf("expected placeholder for no comments, got:\n%s", body)
+	}
+}
+
 func Test_getIssueCommentsByIndexFn_includesAttachments(t *testing.T) {
 	const (
 		owner = "octo"

operation/issue/markdown.go

@@ -0,0 +1,63 @@
+package issue
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+type discussionIssue struct {
+	Number    int64
+	Title     string
+	Author    string
+	State     string
+	Labels    []string
+	Body      string
+	CreatedAt time.Time
+}
+
+type discussionComment struct {
+	Author    string
+	CreatedAt time.Time
+	Body      string
+}
+
+// formatDiscussionMarkdown renders an issue and its comments as a single
+// Markdown document suitable for display without further parsing.
+func formatDiscussionMarkdown(issue discussionIssue, comments []discussionComment) string {
+	var b strings.Builder
+
+	fmt.Fprintf(&b, "# %s (#%d)\n\n", issue.Title, issue.Number)
+	fmt.Fprintf(&b, "**Author:** %s\n", issue.Author)
+	fmt.Fprintf(&b, "**State:** %s\n", issue.State)
+	if len(issue.Labels) > 0 {
+		fmt.Fprintf(&b, "**Labels:** %s\n", strings.Join(issue.Labels, ", "))
+	}
+	if !issue.CreatedAt.IsZero() {
+		fmt.Fprintf(&b, "**Created:** %s\n", issue.CreatedAt.UTC().Format(time.RFC3339))
+	}
+	b.WriteString("\n")
+	b.WriteString(strings.TrimSpace(issue.Body))
+	b.WriteString("\n\n---\n\n## Comments\n\n")
+
+	if len(comments) == 0 {
+		b.WriteString("_No comments yet._\n")
+		return b.String()
+	}
+
+	for i, c := range comments {
+		fmt.Fprintf(&b, "### %s", c.Author)
+		if !c.CreatedAt.IsZero() {
+			fmt.Fprintf(&b, " on %s", c.CreatedAt.UTC().Format(time.RFC3339))
+		}
+		b.WriteString("\n\n")
+		b.WriteString(strings.TrimSpace(c.Body))
+		if i < len(comments)-1 {
+			b.WriteString("\n\n---\n\n")
+		} else {
+			b.WriteString("\n")
+		}
+	}
+
+	return b.String()
+}

operation/issue/markdown_test.go

@@ -0,0 +1,85 @@
+package issue
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func Test_formatDiscussionMarkdown_includesIssueAndComments(t *testing.T) {
+	created := time.Date(2026, 1, 2, 15, 4, 5, 0, time.UTC)
+	commentTime := time.Date(2026, 1, 3, 9, 0, 0, 0, time.UTC)
+	md := formatDiscussionMarkdown(
+		discussionIssue{
+			Number:    42,
+			Title:     "bug with screenshot",
+			Author:    "octocat",
+			State:     "open",
+			Labels:    []string{"bug", "help wanted"},
+			Body:      "see attached",
+			CreatedAt: created,
+		},
+		[]discussionComment{
+			{Author: "reviewer", CreatedAt: commentTime, Body: "thanks for reporting"},
+		},
+	)
+
+	wantSubstrings := []string{
+		"# bug with screenshot (#42)",
+		"**Author:** octocat",
+		"**State:** open",
+		"**Labels:** bug, help wanted",
+		"**Created:** 2026-01-02T15:04:05Z",
+		"see attached",
+		"## Comments",
+		"### reviewer",
+		"2026-01-03T09:00:00Z",
+		"thanks for reporting",
+	}
+	for _, want := range wantSubstrings {
+		if !strings.Contains(md, want) {
+			t.Fatalf("expected markdown to contain %q, got:\n%s", want, md)
+		}
+	}
+}
+
+func Test_formatDiscussionMarkdown_noComments(t *testing.T) {
+	md := formatDiscussionMarkdown(
+		discussionIssue{
+			Number: 1,
+			Title:  "no comments yet",
+			Author: "octocat",
+			State:  "open",
+		},
+		nil,
+	)
+
+	if !strings.Contains(md, "## Comments") {
+		t.Fatalf("expected a Comments section, got:\n%s", md)
+	}
+	if !strings.Contains(md, "_No comments yet._") {
+		t.Fatalf("expected placeholder for no comments, got:\n%s", md)
+	}
+}
+
+func Test_formatDiscussionMarkdown_attachmentBodyIsInlined(t *testing.T) {
+	md := formatDiscussionMarkdown(
+		discussionIssue{
+			Number: 7,
+			Title:  "with attachment",
+			Author: "octocat",
+			State:  "open",
+			Body:   "see attached\n\n[shot.png](https://example/shot.png)",
+		},
+		[]discussionComment{
+			{Author: "reviewer", Body: "log attached\n\n[log.txt](https://example/log.txt)"},
+		},
+	)
+
+	if !strings.Contains(md, "[shot.png](https://example/shot.png)") {
+		t.Fatalf("expected issue attachment link in markdown, got:\n%s", md)
+	}
+	if !strings.Contains(md, "[log.txt](https://example/log.txt)") {
+		t.Fatalf("expected comment attachment link in markdown, got:\n%s", md)
+	}
+}

pkg/to/to.go

@@ -23,6 +23,17 @@ func TextResult(v any) (*mcp.CallToolResult, error) {
 	}, nil
 }
 
+// RawTextResult returns text as-is, without JSON-encoding it. Use it for
+// content that is already meant to be read directly, such as Markdown.
+func RawTextResult(text string) (*mcp.CallToolResult, error) {
+	if flag.Debug {
+		log.Debugf("Text Result: %s", text)
+	}
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{&mcp.TextContent{Text: text}},
+	}, nil
+}
+
 func ErrorResult(err error) (*mcp.CallToolResult, error) {
 	log.Errorf("%s", err.Error())
 	var result mcp.CallToolResult