feat: render issue and PR body as markdown via Gitea API

Add RenderMarkdown method to gitea client that calls POST /api/v1/markdown
to convert raw markdown text to safe HTML. Wire it into IssueDetail and
PullDetail handlers to render body content as formatted markdown.
Falls back gracefully to plain text if the API call fails.

Templates updated to use RenderedBody (template.HTML) with fallback
to raw Issue.Body/Pull.Body when rendering fails.

Closes leeworks-agents/gitea-mobile#35

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Dockerfile

@@ -1,7 +1,7 @@
 # Stage 1: Build
 FROM golang:1.22-alpine AS builder
 WORKDIR /app
-COPY go.mod ./
+COPY go.mod go.sum ./
 RUN go mod download
 COPY . .
 RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /gitea-mobile ./cmd/server

internal/gitea/client.go

@@ -308,60 +308,26 @@ func (c *Client) ListOrgsAndRepos(ctx context.Context, token string) (map[string
 	return result, nil
 }
 
-// PageSize is the number of items returned per page for paginated listings.
-const PageSize = 20
-
-// PaginatedIssues holds a page of issues along with pagination metadata.
-type PaginatedIssues struct {
-	Issues  []Issue
-	HasMore bool
-}
-
-// PaginatedPulls holds a page of pull requests along with pagination metadata.
-type PaginatedPulls struct {
-	Pulls   []PullRequest
-	HasMore bool
-}
-
-// ListAllIssues fetches issues across all repos in the given orgs,
-// using concurrent requests with a semaphore. Results are paginated.
-// The label parameter filters issues by label name (empty string means no filter).
-// The repoFilter parameter narrows results to a single repo name (empty means all repos).
-func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string, state string, page int, label string, repoFilter string) (PaginatedIssues, error) {
-	if state == "" {
-		state = "open"
-	}
-	if page < 1 {
-		page = 1
-	}
-
-	cacheKey := fmt.Sprintf("issues-%s-%s-%s-%s", state, strings.Join(orgs, ","), label, repoFilter)
-	var allIssues []Issue
+// ListAllIssues fetches all open issues across all repos in the given orgs,
+// using concurrent requests with a semaphore.
+func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string) ([]Issue, error) {
+	cacheKey := fmt.Sprintf("issues-%s", strings.Join(orgs, ","))
 	if cached, ok := c.getFromCache(cacheKey); ok {
-		allIssues = cached.([]Issue)
-	} else {
+		return cached.([]Issue), nil
+	}
+
 	// First, collect all repos for the given orgs.
 	var allRepos []Repo
 	for _, org := range orgs {
 		repos, err := c.ListOrgRepos(ctx, token, org)
 		if err != nil {
-				return PaginatedIssues{}, fmt.Errorf("listing repos for %s: %w", org, err)
+			return nil, fmt.Errorf("listing repos for %s: %w", org, err)
 		}
 		allRepos = append(allRepos, repos...)
 	}
 
-		// Filter to a single repo if specified.
-		if repoFilter != "" {
-			var filtered []Repo
-			for _, r := range allRepos {
-				if r.Name == repoFilter {
-					filtered = append(filtered, r)
-				}
-			}
-			allRepos = filtered
-		}
-
 	// Fan out issue fetching across repos.
+	var allIssues []Issue
 	var mu sync.Mutex
 	sem := make(chan struct{}, c.maxConcurrent)
 	var wg sync.WaitGroup
@@ -374,10 +340,7 @@ func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string,
 			sem <- struct{}{}
 			defer func() { <-sem }()
 
-				path := fmt.Sprintf("/repos/%s/issues?state=%s&type=issues&limit=50", r.FullName, state)
-				if label != "" {
-					path += "&labels=" + label
-				}
+			path := fmt.Sprintf("/repos/%s/issues?state=open&type=issues&limit=50", r.FullName)
 			resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
 			if err != nil {
 				mu.Lock()
@@ -414,7 +377,7 @@ func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string,
 	wg.Wait()
 
 	if firstErr != nil {
-			return PaginatedIssues{}, firstErr
+		return nil, firstErr
 	}
 
 	// Sort by updated time, newest first.
@@ -423,58 +386,26 @@ func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string,
 	})
 
 	c.setCache(cacheKey, allIssues)
+	return allIssues, nil
 }
 
-	// Paginate.
-	start := (page - 1) * PageSize
-	if start >= len(allIssues) {
-		return PaginatedIssues{}, nil
-	}
-	end := start + PageSize
-	hasMore := end < len(allIssues)
-	if end > len(allIssues) {
-		end = len(allIssues)
-	}
-
-	return PaginatedIssues{Issues: allIssues[start:end], HasMore: hasMore}, nil
-}
-
-// ListAllPullRequests fetches PRs across all repos in the given orgs.
-// Results are paginated. The label parameter filters PRs by label name.
-// The repoFilter parameter narrows results to a single repo name.
-func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []string, state string, page int, label string, repoFilter string) (PaginatedPulls, error) {
-	if state == "" {
-		state = "open"
-	}
-	if page < 1 {
-		page = 1
-	}
-
-	cacheKey := fmt.Sprintf("pulls-%s-%s-%s-%s", state, strings.Join(orgs, ","), label, repoFilter)
-	var allPRs []PullRequest
+// ListAllPullRequests fetches all open PRs across all repos in the given orgs.
+func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []string) ([]PullRequest, error) {
+	cacheKey := fmt.Sprintf("pulls-%s", strings.Join(orgs, ","))
 	if cached, ok := c.getFromCache(cacheKey); ok {
-		allPRs = cached.([]PullRequest)
-	} else {
+		return cached.([]PullRequest), nil
+	}
+
 	var allRepos []Repo
 	for _, org := range orgs {
 		repos, err := c.ListOrgRepos(ctx, token, org)
 		if err != nil {
-				return PaginatedPulls{}, fmt.Errorf("listing repos for %s: %w", org, err)
+			return nil, fmt.Errorf("listing repos for %s: %w", org, err)
 		}
 		allRepos = append(allRepos, repos...)
 	}
 
-		// Filter to a single repo if specified.
-		if repoFilter != "" {
-			var filtered []Repo
-			for _, r := range allRepos {
-				if r.Name == repoFilter {
-					filtered = append(filtered, r)
-				}
-			}
-			allRepos = filtered
-		}
-
+	var allPRs []PullRequest
 	var mu sync.Mutex
 	sem := make(chan struct{}, c.maxConcurrent)
 	var wg sync.WaitGroup
@@ -487,10 +418,7 @@ func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []s
 			sem <- struct{}{}
 			defer func() { <-sem }()
 
-				path := fmt.Sprintf("/repos/%s/pulls?state=%s&limit=50", r.FullName, state)
-				if label != "" {
-					path += "&labels=" + label
-				}
+			path := fmt.Sprintf("/repos/%s/pulls?state=open&limit=50", r.FullName)
 			resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
 			if err != nil {
 				mu.Lock()
@@ -526,7 +454,7 @@ func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []s
 	wg.Wait()
 
 	if firstErr != nil {
-			return PaginatedPulls{}, firstErr
+		return nil, firstErr
 	}
 
 	sort.Slice(allPRs, func(i, j int) bool {
@@ -534,49 +462,20 @@ func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []s
 	})
 
 	c.setCache(cacheKey, allPRs)
-	}
-
-	// Paginate.
-	start := (page - 1) * PageSize
-	if start >= len(allPRs) {
-		return PaginatedPulls{}, nil
-	}
-	end := start + PageSize
-	hasMore := end < len(allPRs)
-	if end > len(allPRs) {
-		end = len(allPRs)
-	}
-
-	return PaginatedPulls{Pulls: allPRs[start:end], HasMore: hasMore}, nil
+	return allPRs, nil
 }
 
 // GetTriageQueue returns unassigned issues and PRs needing review, sorted by priority.
 func (c *Client) GetTriageQueue(ctx context.Context, token string, orgs []string) ([]TriageItem, error) {
-	// Collect all open issues across all pages.
-	var issues []Issue
-	for page := 1; ; page++ {
-		result, err := c.ListAllIssues(ctx, token, orgs, "open", page, "", "")
+	issues, err := c.ListAllIssues(ctx, token, orgs)
 	if err != nil {
 		return nil, fmt.Errorf("fetching issues for triage: %w", err)
 	}
-		issues = append(issues, result.Issues...)
-		if !result.HasMore {
-			break
-		}
-	}
 
-	// Collect all open PRs across all pages.
-	var prs []PullRequest
-	for page := 1; ; page++ {
-		result, err := c.ListAllPullRequests(ctx, token, orgs, "open", page, "", "")
+	prs, err := c.ListAllPullRequests(ctx, token, orgs)
 	if err != nil {
 		return nil, fmt.Errorf("fetching PRs for triage: %w", err)
 	}
-		prs = append(prs, result.Pulls...)
-		if !result.HasMore {
-			break
-		}
-	}
 
 	var queue []TriageItem
 
@@ -784,49 +683,6 @@ func (c *Client) ApplyLabel(ctx context.Context, token, owner, repo string, inde
 	return nil
 }
 
-// ListCollaborators fetches the list of collaborators (users with access) for a repo.
-func (c *Client) ListCollaborators(ctx context.Context, token, owner, repo string) ([]string, error) {
-	path := fmt.Sprintf("/repos/%s/%s/collaborators?limit=50", owner, repo)
-	resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
-	if err != nil {
-		return nil, fmt.Errorf("fetching collaborators: %w", err)
-	}
-	defer resp.Body.Close()
-
-	var users []struct {
-		Login string `json:"login"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
-		return nil, fmt.Errorf("decoding collaborators: %w", err)
-	}
-
-	var logins []string
-	for _, u := range users {
-		logins = append(logins, u.Login)
-	}
-	return logins, nil
-}
-
-// AssignIssue sets the assignees on an issue.
-func (c *Client) AssignIssue(ctx context.Context, token, owner, repo string, index int64, assignees []string) error {
-	payload, err := json.Marshal(map[string]interface{}{
-		"assignees": assignees,
-	})
-	if err != nil {
-		return fmt.Errorf("marshaling assignees: %w", err)
-	}
-
-	path := fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index)
-	resp, err := c.doRequest(ctx, token, http.MethodPatch, path, strings.NewReader(string(payload)))
-	if err != nil {
-		return fmt.Errorf("assigning issue: %w", err)
-	}
-	resp.Body.Close()
-
-	c.InvalidateAll()
-	return nil
-}
-
 // SubmitReview submits a review on a pull request.
 func (c *Client) SubmitReview(ctx context.Context, token, owner, repo string, index int64, reviewType, body string) error {
 	payload := map[string]interface{}{
@@ -850,61 +706,6 @@ func (c *Client) SubmitReview(ctx context.Context, token, owner, repo string, in
 	return nil
 }
 
-// CloseIssue closes an issue by setting its state to "closed".
-func (c *Client) CloseIssue(ctx context.Context, token, owner, repo string, index int64) error {
-	return c.SetIssueState(ctx, token, owner, repo, index, "closed")
-}
-
-// SetIssueState sets an issue's state (e.g. "open" or "closed").
-func (c *Client) SetIssueState(ctx context.Context, token, owner, repo string, index int64, state string) error {
-	payload, err := json.Marshal(map[string]string{"state": state})
-	if err != nil {
-		return fmt.Errorf("marshaling state change: %w", err)
-	}
-
-	path := fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index)
-	resp, err := c.doRequest(ctx, token, http.MethodPatch, path, strings.NewReader(string(payload)))
-	if err != nil {
-		return fmt.Errorf("setting issue state: %w", err)
-	}
-	resp.Body.Close()
-
-	c.InvalidateAll()
-	return nil
-}
-
-// AddComment creates a comment on an issue and returns the created Comment.
-func (c *Client) AddComment(ctx context.Context, token, owner, repo string, index int64, body string) (*Comment, error) {
-	return c.PostComment(ctx, token, owner, repo, index, body)
-}
-
-// PostComment creates a comment on an issue and returns the created Comment.
-func (c *Client) PostComment(ctx context.Context, token, owner, repo string, index int64, body string) (*Comment, error) {
-	payload, err := json.Marshal(map[string]string{"body": body})
-	if err != nil {
-		return nil, fmt.Errorf("marshaling comment: %w", err)
-	}
-
-	path := fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index)
-	resp, err := c.doRequest(ctx, token, http.MethodPost, path, strings.NewReader(string(payload)))
-	if err != nil {
-		return nil, fmt.Errorf("posting comment: %w", err)
-	}
-	defer resp.Body.Close()
-
-	var comment Comment
-	if err := json.NewDecoder(resp.Body).Decode(&comment); err != nil {
-		return nil, fmt.Errorf("decoding comment: %w", err)
-	}
-
-	// Populate convenience fields.
-	comment.User = comment.RawUser.Login
-	comment.CreatedAt = comment.RawCreatedAt.Format("Jan 2, 2006 15:04")
-
-	c.InvalidateAll()
-	return &comment, nil
-}
-
 // RenderMarkdown renders raw markdown text to HTML using the Gitea API.
 // Falls back to the raw text if the API call fails.
 func (c *Client) RenderMarkdown(ctx context.Context, token, text string) (string, error) {

internal/gitea/client_test.go

@@ -201,167 +201,6 @@ func TestGetTriageQueue_Sorting(t *testing.T) {
 	}
 }
 
-func TestCloseIssue(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPatch {
-			t.Errorf("expected PATCH, got %s", r.Method)
-		}
-		if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42" {
-			t.Errorf("unexpected path: %s", r.URL.Path)
-		}
-		if r.Header.Get("Authorization") != "token test-token" {
-			t.Error("missing or wrong Authorization header")
-		}
-
-		var body map[string]string
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("failed to decode body: %v", err)
-		}
-		if body["state"] != "closed" {
-			t.Errorf("expected state=closed, got %q", body["state"])
-		}
-
-		w.WriteHeader(http.StatusOK)
-		json.NewEncoder(w).Encode(map[string]string{"state": "closed"})
-	}))
-	defer server.Close()
-
-	c := NewClient(server.URL)
-	c.setCache("issues-org1", "should-be-invalidated")
-
-	err := c.CloseIssue(context.Background(), "test-token", "owner1", "repo1", 42)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	// Verify cache was invalidated.
-	_, ok := c.getFromCache("issues-org1")
-	if ok {
-		t.Error("expected cache to be invalidated after CloseIssue")
-	}
-}
-
-func TestSetIssueState(t *testing.T) {
-	tests := []struct {
-		name  string
-		state string
-	}{
-		{"close", "closed"},
-		{"reopen", "open"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if r.Method != http.MethodPatch {
-					t.Errorf("expected PATCH, got %s", r.Method)
-				}
-				if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42" {
-					t.Errorf("unexpected path: %s", r.URL.Path)
-				}
-
-				var body map[string]string
-				if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-					t.Fatalf("failed to decode body: %v", err)
-				}
-				if body["state"] != tt.state {
-					t.Errorf("expected state=%q, got %q", tt.state, body["state"])
-				}
-
-				w.WriteHeader(http.StatusOK)
-				json.NewEncoder(w).Encode(map[string]string{"state": tt.state})
-			}))
-			defer server.Close()
-
-			c := NewClient(server.URL)
-			c.setCache("issues-org1", "should-be-invalidated")
-
-			err := c.SetIssueState(context.Background(), "test-token", "owner1", "repo1", 42, tt.state)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-
-			_, ok := c.getFromCache("issues-org1")
-			if ok {
-				t.Error("expected cache to be invalidated after SetIssueState")
-			}
-		})
-	}
-}
-
-func TestAddComment(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		comment := map[string]interface{}{
-			"id":         1,
-			"body":       "test",
-			"user":       map[string]string{"login": "testuser"},
-			"created_at": "2026-03-26T12:00:00Z",
-		}
-		json.NewEncoder(w).Encode(comment)
-	}))
-	defer server.Close()
-
-	c := NewClient(server.URL)
-	comment, err := c.AddComment(context.Background(), "test-token", "owner1", "repo1", 42, "test")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if comment.Body != "test" {
-		t.Errorf("comment.Body = %q, want %q", comment.Body, "test")
-	}
-}
-
-func TestPostComment(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPost {
-			t.Errorf("expected POST, got %s", r.Method)
-		}
-		if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42/comments" {
-			t.Errorf("unexpected path: %s", r.URL.Path)
-		}
-
-		var body map[string]string
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("failed to decode body: %v", err)
-		}
-		if body["body"] != "test comment" {
-			t.Errorf("expected body='test comment', got %q", body["body"])
-		}
-
-		comment := map[string]interface{}{
-			"id":   1,
-			"body": body["body"],
-			"user": map[string]string{"login": "testuser"},
-			"created_at": "2026-03-26T12:00:00Z",
-		}
-		json.NewEncoder(w).Encode(comment)
-	}))
-	defer server.Close()
-
-	c := NewClient(server.URL)
-	c.setCache("issues-org1", "should-be-invalidated")
-
-	comment, err := c.PostComment(context.Background(), "test-token", "owner1", "repo1", 42, "test comment")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if comment.Body != "test comment" {
-		t.Errorf("comment.Body = %q, want %q", comment.Body, "test comment")
-	}
-	if comment.User != "testuser" {
-		t.Errorf("comment.User = %q, want %q", comment.User, "testuser")
-	}
-	if comment.ID != 1 {
-		t.Errorf("comment.ID = %d, want 1", comment.ID)
-	}
-
-	// Verify cache was invalidated.
-	_, ok := c.getFromCache("issues-org1")
-	if ok {
-		t.Error("expected cache to be invalidated after PostComment")
-	}
-}
-
 // sortTriageQueue is a test helper applying the same sort as GetTriageQueue.
 func sortTriageQueue(queue []TriageItem) {
 	for i := 0; i < len(queue); i++ {

internal/handlers/handlers.go

@@ -38,15 +38,8 @@ func (h *Handler) RegisterRoutes(mux *http.ServeMux) {
 
 	// Issues.
 	mux.HandleFunc("GET /issues", h.ListIssues)
-	mux.HandleFunc("GET /issues/new", h.NewIssue)
-	mux.HandleFunc("GET /issues/new/labels", h.NewIssueLabels)
 	mux.HandleFunc("POST /issues", h.CreateIssue)
 	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/labels", h.ApplyLabels)
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/assignees", h.AssignIssue)
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/close", h.CloseIssue)
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/state", h.SetIssueState)
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/comments", h.AddComment)
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/comment", h.AddComment)
 
 	// Issue detail.
 	mux.HandleFunc("GET /issues/{owner}/{repo}/{index}", h.IssueDetail)
@@ -55,7 +48,6 @@ func (h *Handler) RegisterRoutes(mux *http.ServeMux) {
 	mux.HandleFunc("GET /pulls", h.ListPulls)
 	mux.HandleFunc("GET /pulls/{owner}/{repo}/{index}", h.PullDetail)
 	mux.HandleFunc("POST /pulls/{owner}/{repo}/{index}/review", h.SubmitReview)
-	mux.HandleFunc("POST /pulls/{owner}/{repo}/{index}/state", h.SetPullState)
 
 	// Settings (handled separately for auth bypass).
 	settingsHandler := &SettingsHandler{
@@ -120,10 +112,6 @@ var basePage = template.Must(template.New("base").Parse(`<!DOCTYPE html>
   <script src="/static/htmx.min.js"></script>
 </head>
 <body>
-  <header class="top-bar">
-    <span class="top-bar-title">Gitea Mobile</span>
-    <button class="refresh-btn" hx-get="" hx-target="#main-content" hx-swap="innerHTML" aria-label="Refresh">&#8635;</button>
-  </header>
   <div class="content" id="main-content">
     {{.Content}}
   </div>
@@ -191,264 +179,159 @@ func (h *Handler) Dashboard(w http.ResponseWriter, r *http.Request) {
 
 	token := getToken(r)
 	orgs := h.getUserOrgs(r)
-	selectedOrg := r.URL.Query().Get("org")
-
-	type dashboardData struct {
-		Items       []giteaclient.TriageItem
-		Orgs        []string
-		SelectedOrg string
-		Error       string
-	}
-
-	data := dashboardData{
-		Orgs:        orgs,
-		SelectedOrg: selectedOrg,
-	}
 
 	if len(orgs) == 0 {
-		data.Error = "No organizations found. Check your token permissions."
-	} else {
-		// Determine which orgs to query.
-		queryOrgs := orgs
-		if selectedOrg != "" {
-			queryOrgs = []string{selectedOrg}
+		renderPage(w, r, "Dashboard", "dashboard",
+			`<h1>Dashboard</h1><p class="empty">No organizations found. Check your token permissions.</p>`)
+		return
 	}
 
-		queue, err := h.Client.GetTriageQueue(r.Context(), token, queryOrgs)
+	queue, err := h.Client.GetTriageQueue(r.Context(), token, orgs)
 	if err != nil {
 		slog.Error("failed to get triage queue", "error", err)
-			data.Error = "Error loading triage queue."
-		} else {
-			data.Items = queue
-		}
-	}
-
-	tmpl, err := template.ParseFiles("internal/templates/dashboard.html")
-	if err != nil {
-		slog.Error("failed to parse dashboard template", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
+		renderPage(w, r, "Dashboard", "dashboard",
+			`<h1>Dashboard</h1><p class="empty">Error loading triage queue.</p>`)
 		return
 	}
 
-	var buf strings.Builder
-	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
-		slog.Error("failed to execute dashboard template", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
+	if len(queue) == 0 {
+		renderPage(w, r, "Dashboard", "dashboard",
+			`<h1>Dashboard</h1><p class="empty">No items need attention. Nice work!</p>`)
 		return
 	}
 
-	renderPage(w, r, "Dashboard", "dashboard", buf.String())
+	content := `<h1>Dashboard</h1>`
+	for _, item := range queue {
+		typeBadge := `<span class="type-badge type-issue">issue</span>`
+		if item.Type == "pull" {
+			typeBadge = `<span class="type-badge type-pull">PR</span>`
+		}
+
+		labels := ""
+		for _, l := range item.Labels {
+			color := "#8b949e"
+			switch l {
+			case "P1":
+				color = "#f85149"
+			case "P2":
+				color = "#d29922"
+			case "P3":
+				color = "#58a6ff"
+			}
+			labels += fmt.Sprintf(`<span class="label" style="color:%s;border:1px solid %s">%s</span>`, color, color, template.HTMLEscapeString(l))
+		}
+
+		content += fmt.Sprintf(`<div class="card">
+  <div class="card-title">%s %s</div>
+  <div class="card-meta">%s/%s #%d %s</div>
+</div>`, typeBadge, template.HTMLEscapeString(item.Title),
+			template.HTMLEscapeString(item.RepoOwner),
+			template.HTMLEscapeString(item.RepoName),
+			item.Number, labels)
+	}
+
+	renderPage(w, r, "Dashboard", "dashboard", content)
 }
 
 // ListIssues handles GET /issues.
 func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)
-	orgNames := h.getUserOrgs(r)
+	orgs := h.getUserOrgs(r)
 
-	type issuesData struct {
-		Issues        []giteaclient.Issue
-		Orgs          []string
-		SelectedOrg   string
-		SelectedState string
-		SelectedLabel string
-		SelectedRepo  string
-		Repos         []string
-		HasMore       bool
-		NextPage      int
-		Error         string
+	if len(orgs) == 0 {
+		renderPage(w, r, "Issues", "issues",
+			`<h1>Issues</h1><p class="empty">No organizations found.</p>`)
+		return
 	}
 
-	selectedOrg := r.URL.Query().Get("org")
-	selectedState := r.URL.Query().Get("state")
-	if selectedState == "" {
-		selectedState = "open"
-	}
-	selectedLabel := r.URL.Query().Get("label")
-	selectedRepo := r.URL.Query().Get("repo")
-	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
-	if page < 1 {
-		page = 1
-	}
-
-	data := issuesData{
-		Orgs:          orgNames,
-		SelectedOrg:   selectedOrg,
-		SelectedState: selectedState,
-		SelectedLabel: selectedLabel,
-		SelectedRepo:  selectedRepo,
-	}
-
-	if len(orgNames) == 0 {
-		data.Error = "No organizations found."
-	} else {
-		// Filter to selected org if specified.
-		queryOrgs := orgNames
-		if selectedOrg != "" {
-			queryOrgs = []string{selectedOrg}
-
-			// Populate repo list for the selected org.
-			repos, err := h.Client.ListOrgRepos(r.Context(), token, selectedOrg)
-			if err != nil {
-				slog.Warn("failed to list repos for org filter", "error", err, "org", selectedOrg)
-			} else {
-				for _, repo := range repos {
-					data.Repos = append(data.Repos, repo.Name)
-				}
-			}
-		}
-
-		result, err := h.Client.ListAllIssues(r.Context(), token, queryOrgs, selectedState, page, selectedLabel, selectedRepo)
+	issues, err := h.Client.ListAllIssues(r.Context(), token, orgs)
 	if err != nil {
 		slog.Error("failed to list issues", "error", err)
-			data.Error = "Error loading issues."
-		} else {
-			data.Issues = result.Issues
-			data.HasMore = result.HasMore
-			if result.HasMore {
-				data.NextPage = page + 1
-			}
-		}
-	}
-
-	// For HTMX infinite-scroll requests (page > 1), return only the card fragment.
-	if isHTMX(r) && page > 1 {
-		tmpl, err := template.ParseFiles("internal/templates/issues.html")
-		if err != nil {
-			slog.Error("failed to parse issues template", "error", err)
-			http.Error(w, "template error", http.StatusInternalServerError)
-			return
-		}
-		var buf strings.Builder
-		if err := tmpl.ExecuteTemplate(&buf, "cards", data); err != nil {
-			slog.Error("failed to execute issues cards template", "error", err)
-			http.Error(w, "template error", http.StatusInternalServerError)
-			return
-		}
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprint(w, buf.String())
+		renderPage(w, r, "Issues", "issues",
+			`<h1>Issues</h1><p class="empty">Error loading issues.</p>`)
 		return
 	}
 
-	tmpl, err := template.ParseFiles("internal/templates/issues.html")
-	if err != nil {
-		slog.Error("failed to parse issues template", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
+	if len(issues) == 0 {
+		renderPage(w, r, "Issues", "issues",
+			`<h1>Issues</h1><p class="empty">No open issues found.</p>`)
 		return
 	}
 
-	var buf strings.Builder
-	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
-		slog.Error("failed to execute issues template", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
-		return
+	content := `<h1>Issues</h1>`
+	for _, issue := range issues {
+		labels := ""
+		for _, l := range issue.Labels {
+			labels += fmt.Sprintf(`<span class="label" style="color:#%s;border:1px solid #%s">%s</span>`,
+				l.Color, l.Color, template.HTMLEscapeString(l.Name))
 		}
 
-	renderPage(w, r, "Issues", "issues", buf.String())
+		assignee := ""
+		if issue.Assignee != nil {
+			assignee = fmt.Sprintf(` &middot; %s`, template.HTMLEscapeString(issue.Assignee.Login))
+		}
+
+		content += fmt.Sprintf(`<div class="card">
+  <div class="card-title">%s</div>
+  <div class="card-meta">%s/%s #%d %s%s</div>
+</div>`, template.HTMLEscapeString(issue.Title),
+			template.HTMLEscapeString(issue.RepoOwner),
+			template.HTMLEscapeString(issue.RepoName),
+			issue.Number, labels, assignee)
+	}
+
+	renderPage(w, r, "Issues", "issues", content)
 }
 
 // ListPulls handles GET /pulls.
 func (h *Handler) ListPulls(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)
-	orgNames := h.getUserOrgs(r)
+	orgs := h.getUserOrgs(r)
 
-	type pullsData struct {
-		Pulls         []giteaclient.PullRequest
-		Orgs          []string
-		SelectedOrg   string
-		SelectedState string
-		SelectedLabel string
-		SelectedRepo  string
-		Repos         []string
-		HasMore       bool
-		NextPage      int
-		Error         string
+	if len(orgs) == 0 {
+		renderPage(w, r, "Pull Requests", "pulls",
+			`<h1>Pull Requests</h1><p class="empty">No organizations found.</p>`)
+		return
 	}
 
-	selectedOrg := r.URL.Query().Get("org")
-	selectedState := r.URL.Query().Get("state")
-	if selectedState == "" {
-		selectedState = "open"
-	}
-	selectedLabel := r.URL.Query().Get("label")
-	selectedRepo := r.URL.Query().Get("repo")
-	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
-	if page < 1 {
-		page = 1
-	}
-
-	data := pullsData{
-		Orgs:          orgNames,
-		SelectedOrg:   selectedOrg,
-		SelectedState: selectedState,
-		SelectedLabel: selectedLabel,
-		SelectedRepo:  selectedRepo,
-	}
-
-	if len(orgNames) == 0 {
-		data.Error = "No organizations found."
-	} else {
-		queryOrgs := orgNames
-		if selectedOrg != "" {
-			queryOrgs = []string{selectedOrg}
-
-			// Populate repo list for the selected org.
-			repos, err := h.Client.ListOrgRepos(r.Context(), token, selectedOrg)
-			if err != nil {
-				slog.Warn("failed to list repos for org filter", "error", err, "org", selectedOrg)
-			} else {
-				for _, repo := range repos {
-					data.Repos = append(data.Repos, repo.Name)
-				}
-			}
-		}
-
-		result, err := h.Client.ListAllPullRequests(r.Context(), token, queryOrgs, selectedState, page, selectedLabel, selectedRepo)
+	prs, err := h.Client.ListAllPullRequests(r.Context(), token, orgs)
 	if err != nil {
 		slog.Error("failed to list pull requests", "error", err)
-			data.Error = "Error loading pull requests."
-		} else {
-			data.Pulls = result.Pulls
-			data.HasMore = result.HasMore
-			if result.HasMore {
-				data.NextPage = page + 1
-			}
-		}
-	}
-
-	// For HTMX infinite-scroll requests (page > 1), return only the card fragment.
-	if isHTMX(r) && page > 1 {
-		tmpl, err := template.ParseFiles("internal/templates/pulls.html")
-		if err != nil {
-			slog.Error("failed to parse pulls template", "error", err)
-			http.Error(w, "template error", http.StatusInternalServerError)
-			return
-		}
-		var buf strings.Builder
-		if err := tmpl.ExecuteTemplate(&buf, "cards", data); err != nil {
-			slog.Error("failed to execute pulls cards template", "error", err)
-			http.Error(w, "template error", http.StatusInternalServerError)
-			return
-		}
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprint(w, buf.String())
+		renderPage(w, r, "Pull Requests", "pulls",
+			`<h1>Pull Requests</h1><p class="empty">Error loading pull requests.</p>`)
 		return
 	}
 
-	tmpl, err := template.ParseFiles("internal/templates/pulls.html")
-	if err != nil {
-		slog.Error("failed to parse pulls template", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
+	if len(prs) == 0 {
+		renderPage(w, r, "Pull Requests", "pulls",
+			`<h1>Pull Requests</h1><p class="empty">No open pull requests found.</p>`)
 		return
 	}
 
-	var buf strings.Builder
-	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
-		slog.Error("failed to execute pulls template", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
-		return
+	content := `<h1>Pull Requests</h1>`
+	for _, pr := range prs {
+		labels := ""
+		for _, l := range pr.Labels {
+			labels += fmt.Sprintf(`<span class="label" style="color:#%s;border:1px solid #%s">%s</span>`,
+				l.Color, l.Color, template.HTMLEscapeString(l.Name))
 		}
 
-	renderPage(w, r, "Pull Requests", "pulls", buf.String())
+		stats := fmt.Sprintf(`<span style="color:#3fb950">+%d</span> <span style="color:#f85149">-%d</span>`, pr.Additions, pr.Deletions)
+		mergeStatus := ""
+		if pr.Mergeable {
+			mergeStatus = `<span style="color:#3fb950;font-size:0.7rem;">mergeable</span>`
+		}
+
+		content += fmt.Sprintf(`<div class="card">
+  <div class="card-title"><span class="type-badge type-pull">PR</span> %s</div>
+  <div class="card-meta">%s/%s #%d %s %s %s</div>
+</div>`, template.HTMLEscapeString(pr.Title),
+			template.HTMLEscapeString(pr.RepoOwner),
+			template.HTMLEscapeString(pr.RepoName),
+			pr.Number, labels, stats, mergeStatus)
+	}
+
+	renderPage(w, r, "Pull Requests", "pulls", content)
 }
 
 // IssueDetail handles GET /issues/{owner}/{repo}/{index}.
@@ -484,12 +367,6 @@ func (h *Handler) IssueDetail(w http.ResponseWriter, r *http.Request) {
 		labels = nil
 	}
 
-	collaborators, err := h.Client.ListCollaborators(r.Context(), token, owner, repo)
-	if err != nil {
-		slog.Error("failed to get collaborators", "error", err)
-		collaborators = nil
-	}
-
 	// Render markdown body if present.
 	var renderedBody template.HTML
 	if issue.Body != "" {
@@ -514,7 +391,6 @@ func (h *Handler) IssueDetail(w http.ResponseWriter, r *http.Request) {
 		RenderedBody    template.HTML
 		Comments        []giteaclient.Comment
 		AvailableLabels []giteaclient.Label
-		Collaborators   []string
 	}
 
 	data := templateData{
@@ -522,7 +398,6 @@ func (h *Handler) IssueDetail(w http.ResponseWriter, r *http.Request) {
 		RenderedBody:    renderedBody,
 		Comments:        comments,
 		AvailableLabels: labels,
-		Collaborators:   collaborators,
 	}
 
 	var buf strings.Builder
@@ -567,13 +442,6 @@ func (h *Handler) PullDetail(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	// Fetch comments for this PR (Gitea uses the issues endpoint for PR comments).
-	comments, err := h.Client.GetIssueComments(r.Context(), token, owner, repo, index)
-	if err != nil {
-		slog.Warn("failed to fetch PR comments", "error", err, "owner", owner, "repo", repo, "index", index)
-		// Non-fatal: continue rendering without comments.
-	}
-
 	// Build the content HTML using the template.
 	tmpl, err := template.ParseFiles("internal/templates/pull_detail.html")
 	if err != nil {
@@ -585,13 +453,11 @@ func (h *Handler) PullDetail(w http.ResponseWriter, r *http.Request) {
 	type templateData struct {
 		Pull         *giteaclient.PullRequest
 		RenderedBody template.HTML
-		Comments     []giteaclient.Comment
 	}
 
 	data := templateData{
 		Pull:         pr,
 		RenderedBody: renderedBody,
-		Comments:     comments,
 	}
 
 	var buf strings.Builder
@@ -604,73 +470,6 @@ func (h *Handler) PullDetail(w http.ResponseWriter, r *http.Request) {
 	renderPage(w, r, fmt.Sprintf("PR #%d", index), "pulls", buf.String())
 }
 
-// NewIssue handles GET /issues/new — renders the create-issue form.
-func (h *Handler) NewIssue(w http.ResponseWriter, r *http.Request) {
-	token := getToken(r)
-
-	repos, err := h.Client.ListOrgsAndRepos(r.Context(), token)
-	if err != nil {
-		slog.Error("failed to list repos for new issue form", "error", err)
-		renderPage(w, r, "New Issue", "issues",
-			`<h1>New Issue</h1><p class="empty">Error loading repositories.</p>`)
-		return
-	}
-
-	tmpl, err := template.ParseFiles("internal/templates/create_issue.html")
-	if err != nil {
-		slog.Error("failed to parse create_issue template", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
-		return
-	}
-
-	type templateData struct {
-		Repos map[string][]giteaclient.Repo
-	}
-
-	data := templateData{Repos: repos}
-
-	var buf strings.Builder
-	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
-		slog.Error("failed to execute create_issue template", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
-		return
-	}
-
-	renderPage(w, r, "New Issue", "issues", buf.String())
-}
-
-// NewIssueLabels handles GET /issues/new/labels — returns label checkboxes for a repo.
-func (h *Handler) NewIssueLabels(w http.ResponseWriter, r *http.Request) {
-	token := getToken(r)
-	owner := r.URL.Query().Get("owner")
-	repo := r.URL.Query().Get("repo")
-
-	if owner == "" || repo == "" {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprint(w, `<span class="empty">Select a repository first.</span>`)
-		return
-	}
-
-	labels, err := h.Client.GetRepoLabels(r.Context(), token, owner, repo)
-	if err != nil {
-		slog.Error("failed to fetch labels", "error", err, "owner", owner, "repo", repo)
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprint(w, `<span class="empty">Error loading labels.</span>`)
-		return
-	}
-
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if len(labels) == 0 {
-		fmt.Fprint(w, `<span class="empty">No labels available for this repository.</span>`)
-		return
-	}
-
-	for _, l := range labels {
-		fmt.Fprintf(w, `<label style="display:inline-block;margin:0.25rem 0.5rem 0.25rem 0;cursor:pointer;"><input type="checkbox" name="label_ids" value="%d" style="margin-right:0.25rem;"> <span class="label" style="color:#%s;border:1px solid #%s">%s</span></label>`,
-			l.ID, template.HTMLEscapeString(l.Color), template.HTMLEscapeString(l.Color), template.HTMLEscapeString(l.Name))
-	}
-}
-
 // CreateIssue handles POST /issues.
 func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)
@@ -684,35 +483,14 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 	title := r.FormValue("title")
 	body := r.FormValue("body")
 
-	// Parse label IDs from form checkboxes.
-	var labelIDs []int64
-	for _, idStr := range r.Form["label_ids"] {
-		id, err := strconv.ParseInt(idStr, 10, 64)
-		if err == nil {
-			labelIDs = append(labelIDs, id)
-		}
-	}
-
 	if owner == "" || repo == "" || title == "" {
-		if isHTMX(r) {
-			w.Header().Set("Content-Type", "text/html; charset=utf-8")
-			w.WriteHeader(http.StatusBadRequest)
-			fmt.Fprint(w, `<span class="empty">owner, repo, and title are required</span>`)
-			return
-		}
 		http.Error(w, "owner, repo, and title are required", http.StatusBadRequest)
 		return
 	}
 
-	issue, err := h.Client.CreateIssue(r.Context(), token, owner, repo, title, body, labelIDs)
+	issue, err := h.Client.CreateIssue(r.Context(), token, owner, repo, title, body, nil)
 	if err != nil {
 		slog.Error("failed to create issue", "error", err)
-		if isHTMX(r) {
-			w.Header().Set("Content-Type", "text/html; charset=utf-8")
-			w.WriteHeader(http.StatusInternalServerError)
-			fmt.Fprint(w, `<span class="empty">Failed to create issue. Please try again.</span>`)
-			return
-		}
 		http.Error(w, "failed to create issue", http.StatusInternalServerError)
 		return
 	}
@@ -773,210 +551,6 @@ func (h *Handler) ApplyLabels(w http.ResponseWriter, r *http.Request) {
 	http.Redirect(w, r, fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
 }
 
-// AssignIssue handles POST /issues/{owner}/{repo}/{index}/assignees.
-func (h *Handler) AssignIssue(w http.ResponseWriter, r *http.Request) {
-	token := getToken(r)
-	owner := r.PathValue("owner")
-	repo := r.PathValue("repo")
-	indexStr := r.PathValue("index")
-
-	index, err := strconv.ParseInt(indexStr, 10, 64)
-	if err != nil {
-		http.Error(w, "invalid issue index", http.StatusBadRequest)
-		return
-	}
-
-	if err := r.ParseForm(); err != nil {
-		http.Error(w, "bad request", http.StatusBadRequest)
-		return
-	}
-
-	assignee := r.FormValue("assignee")
-	if assignee == "" {
-		http.Error(w, "assignee is required", http.StatusBadRequest)
-		return
-	}
-
-	if err := h.Client.AssignIssue(r.Context(), token, owner, repo, index, []string{assignee}); err != nil {
-		slog.Error("failed to assign issue", "error", err, "owner", owner, "repo", repo, "index", index, "assignee", assignee)
-		http.Error(w, "failed to assign issue", http.StatusInternalServerError)
-		return
-	}
-
-	if isHTMX(r) {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprintf(w, `<span style="color:#3fb950">Assigned to %s</span>`, template.HTMLEscapeString(assignee))
-		return
-	}
-
-	http.Redirect(w, r, fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
-}
-
-// CloseIssue handles POST /issues/{owner}/{repo}/{index}/close.
-func (h *Handler) CloseIssue(w http.ResponseWriter, r *http.Request) {
-	token := getToken(r)
-	owner := r.PathValue("owner")
-	repo := r.PathValue("repo")
-	indexStr := r.PathValue("index")
-
-	index, err := strconv.ParseInt(indexStr, 10, 64)
-	if err != nil {
-		http.Error(w, "invalid issue index", http.StatusBadRequest)
-		return
-	}
-
-	if err := h.Client.CloseIssue(r.Context(), token, owner, repo, index); err != nil {
-		slog.Error("failed to close issue", "error", err, "owner", owner, "repo", repo, "index", index)
-		http.Error(w, "failed to close issue", http.StatusInternalServerError)
-		return
-	}
-
-	if isHTMX(r) {
-		w.Header().Set("HX-Redirect", fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index))
-		w.WriteHeader(http.StatusOK)
-		return
-	}
-
-	http.Redirect(w, r, fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
-}
-
-// SetIssueState handles POST /issues/{owner}/{repo}/{index}/state.
-func (h *Handler) SetIssueState(w http.ResponseWriter, r *http.Request) {
-	token := getToken(r)
-	owner := r.PathValue("owner")
-	repo := r.PathValue("repo")
-	indexStr := r.PathValue("index")
-
-	index, err := strconv.ParseInt(indexStr, 10, 64)
-	if err != nil {
-		http.Error(w, "invalid issue index", http.StatusBadRequest)
-		return
-	}
-
-	if err := r.ParseForm(); err != nil {
-		http.Error(w, "bad request", http.StatusBadRequest)
-		return
-	}
-
-	state := r.FormValue("state")
-	if state != "open" && state != "closed" {
-		http.Error(w, "state must be 'open' or 'closed'", http.StatusBadRequest)
-		return
-	}
-
-	if err := h.Client.SetIssueState(r.Context(), token, owner, repo, index, state); err != nil {
-		slog.Error("failed to set issue state", "error", err, "owner", owner, "repo", repo, "index", index, "state", state)
-		http.Error(w, "failed to update issue state", http.StatusInternalServerError)
-		return
-	}
-
-	if isHTMX(r) {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		if state == "closed" {
-			fmt.Fprintf(w, `<span class="state-closed" id="issue-state">closed</span>
-<button class="btn btn-secondary" hx-post="/issues/%s/%s/%d/state" hx-vals='{"state":"open"}' hx-target="#state-section" hx-swap="innerHTML">Reopen Issue</button>`,
-				template.HTMLEscapeString(owner), template.HTMLEscapeString(repo), index)
-		} else {
-			fmt.Fprintf(w, `<span class="state-open" id="issue-state">open</span>
-<button class="btn btn-danger" hx-post="/issues/%s/%s/%d/state" hx-vals='{"state":"closed"}' hx-target="#state-section" hx-swap="innerHTML">Close Issue</button>`,
-				template.HTMLEscapeString(owner), template.HTMLEscapeString(repo), index)
-		}
-		return
-	}
-
-	http.Redirect(w, r, fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
-}
-
-// SetPullState handles POST /pulls/{owner}/{repo}/{index}/state.
-func (h *Handler) SetPullState(w http.ResponseWriter, r *http.Request) {
-	token := getToken(r)
-	owner := r.PathValue("owner")
-	repo := r.PathValue("repo")
-	indexStr := r.PathValue("index")
-
-	index, err := strconv.ParseInt(indexStr, 10, 64)
-	if err != nil {
-		http.Error(w, "invalid pull request index", http.StatusBadRequest)
-		return
-	}
-
-	if err := r.ParseForm(); err != nil {
-		http.Error(w, "bad request", http.StatusBadRequest)
-		return
-	}
-
-	state := r.FormValue("state")
-	if state != "open" && state != "closed" {
-		http.Error(w, "state must be 'open' or 'closed'", http.StatusBadRequest)
-		return
-	}
-
-	if err := h.Client.SetIssueState(r.Context(), token, owner, repo, index, state); err != nil {
-		slog.Error("failed to set pull request state", "error", err, "owner", owner, "repo", repo, "index", index, "state", state)
-		http.Error(w, "failed to update pull request state", http.StatusInternalServerError)
-		return
-	}
-
-	if isHTMX(r) {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		if state == "closed" {
-			fmt.Fprintf(w, `<span class="state-closed" id="pull-state">closed</span>
-<button class="btn btn-secondary" hx-post="/pulls/%s/%s/%d/state" hx-vals='{"state":"open"}' hx-target="#state-section" hx-swap="innerHTML">Reopen PR</button>`,
-				template.HTMLEscapeString(owner), template.HTMLEscapeString(repo), index)
-		} else {
-			fmt.Fprintf(w, `<span class="state-open" id="pull-state">open</span>
-<button class="btn btn-danger" hx-post="/pulls/%s/%s/%d/state" hx-vals='{"state":"closed"}' hx-target="#state-section" hx-swap="innerHTML">Close PR</button>`,
-				template.HTMLEscapeString(owner), template.HTMLEscapeString(repo), index)
-		}
-		return
-	}
-
-	http.Redirect(w, r, fmt.Sprintf("/pulls/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
-}
-
-// AddComment handles POST /issues/{owner}/{repo}/{index}/comment.
-func (h *Handler) AddComment(w http.ResponseWriter, r *http.Request) {
-	token := getToken(r)
-	owner := r.PathValue("owner")
-	repo := r.PathValue("repo")
-	indexStr := r.PathValue("index")
-
-	index, err := strconv.ParseInt(indexStr, 10, 64)
-	if err != nil {
-		http.Error(w, "invalid issue index", http.StatusBadRequest)
-		return
-	}
-
-	if err := r.ParseForm(); err != nil {
-		http.Error(w, "bad request", http.StatusBadRequest)
-		return
-	}
-
-	body := r.FormValue("body")
-	if body == "" {
-		http.Error(w, "comment body is required", http.StatusBadRequest)
-		return
-	}
-
-	comment, err := h.Client.PostComment(r.Context(), token, owner, repo, index, body)
-	if err != nil {
-		slog.Error("failed to post comment", "error", err, "owner", owner, "repo", repo, "index", index)
-		http.Error(w, "failed to post comment", http.StatusInternalServerError)
-		return
-	}
-
-	if isHTMX(r) {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprintf(w, `<div class="card comment">
-  <div class="card-meta">%s &middot; %s</div>
-  <div class="card-body">%s</div>
-</div>`, template.HTMLEscapeString(comment.User), template.HTMLEscapeString(comment.CreatedAt), template.HTMLEscapeString(comment.Body))
-		return
-	}
-
-	http.Redirect(w, r, fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
-}
-
 // SubmitReview handles POST /pulls/{owner}/{repo}/{index}/review.
 func (h *Handler) SubmitReview(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)

internal/handlers/handlers_test.go

@@ -135,54 +135,6 @@ func TestSubmitReview_MissingEventType(t *testing.T) {
 	}
 }
 
-func TestSetIssueState_InvalidState(t *testing.T) {
-	h := newTestHandler()
-	mux := http.NewServeMux()
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/state", h.SetIssueState)
-
-	req := httptest.NewRequest(http.MethodPost, "/issues/org/repo/1/state", nil)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	w := httptest.NewRecorder()
-
-	mux.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("status = %d, want %d", w.Code, http.StatusBadRequest)
-	}
-}
-
-func TestSetIssueState_InvalidIndex(t *testing.T) {
-	h := newTestHandler()
-	mux := http.NewServeMux()
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/state", h.SetIssueState)
-
-	req := httptest.NewRequest(http.MethodPost, "/issues/org/repo/abc/state", nil)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	w := httptest.NewRecorder()
-
-	mux.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("status = %d, want %d", w.Code, http.StatusBadRequest)
-	}
-}
-
-func TestAddComment_EmptyBody(t *testing.T) {
-	h := newTestHandler()
-	mux := http.NewServeMux()
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/comments", h.AddComment)
-
-	req := httptest.NewRequest(http.MethodPost, "/issues/org/repo/1/comments", nil)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	w := httptest.NewRecorder()
-
-	mux.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("status = %d, want %d", w.Code, http.StatusBadRequest)
-	}
-}
-
 func contains(s, substr string) bool {
 	return len(s) >= len(substr) && searchString(s, substr)
 }

internal/templates/create_issue.html

@@ -1,29 +1,23 @@
 {{define "content"}}
 <h1>Create Issue</h1>
 
-<div id="form-error" class="empty" style="display:none;"></div>
-
-<form id="create-issue-form" hx-post="/issues" hx-swap="innerHTML" hx-target="#main-content">
+<form hx-post="/issues" hx-swap="innerHTML" hx-target="#main-content">
   <div class="form-group">
     <label for="repo-select">Repository</label>
-    <input list="repo-options" id="repo-select" name="owner_repo"
-           placeholder="Type to search repositories..." required autocomplete="off">
-    <datalist id="repo-options">
+    <select id="repo-select" name="owner_repo" required>
+      <option value="">Select a repository...</option>
       {{range $org, $repos := .Repos}}
+      <optgroup label="{{$org}}">
         {{range $repos}}
         <option value="{{.Owner.Login}}/{{.Name}}">{{.FullName}}</option>
         {{end}}
+      </optgroup>
       {{end}}
-    </datalist>
+    </select>
     <input type="hidden" name="owner" id="owner-input">
     <input type="hidden" name="repo" id="repo-input">
   </div>
 
-  <div class="form-group" id="label-section" style="display:none;">
-    <label>Labels</label>
-    <div id="label-list"></div>
-  </div>
-
   <div class="form-group">
     <label for="title">Title</label>
     <input type="text" id="title" name="title" placeholder="Issue title" required>
@@ -38,88 +32,11 @@
 </form>
 
 <script>
-  (function() {
-    var repoSelect = document.getElementById('repo-select');
-    var ownerInput = document.getElementById('owner-input');
-    var repoInput = document.getElementById('repo-input');
-    var formError = document.getElementById('form-error');
-
-    // Build a set of valid repo values for validation.
-    var validRepos = {};
-    var options = document.getElementById('repo-options').options;
-    for (var i = 0; i < options.length; i++) {
-      validRepos[options[i].value] = true;
-    }
-
-    function splitOwnerRepo() {
-      var val = repoSelect.value;
-      if (val && val.indexOf('/') !== -1) {
-        var parts = val.split('/');
-        ownerInput.value = parts[0] || '';
-        repoInput.value = parts[1] || '';
-      } else {
-        ownerInput.value = '';
-        repoInput.value = '';
-      }
-    }
-
-    var debounceTimer = null;
-    repoSelect.addEventListener('input', function() {
-      clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(function() {
-        splitOwnerRepo();
-        var labelSection = document.getElementById('label-section');
-        var labelList = document.getElementById('label-list');
-        if (ownerInput.value && repoInput.value && validRepos[repoSelect.value]) {
-          labelList.innerHTML = '<span class="empty">Loading labels...</span>';
-          labelSection.style.display = 'block';
-          htmx.ajax('GET', '/issues/new/labels?owner=' + encodeURIComponent(ownerInput.value) + '&repo=' + encodeURIComponent(repoInput.value), {target: '#label-list', swap: 'innerHTML'});
-        } else {
-          labelSection.style.display = 'none';
-          labelList.innerHTML = '';
-        }
-      }, 300);
+  // Split owner/repo from select into hidden fields.
+  document.getElementById('repo-select').addEventListener('change', function() {
+    var parts = this.value.split('/');
+    document.getElementById('owner-input').value = parts[0] || '';
+    document.getElementById('repo-input').value = parts[1] || '';
   });
-
-    // Also handle the change event for when a datalist option is selected directly.
-    repoSelect.addEventListener('change', function() {
-      clearTimeout(debounceTimer);
-      splitOwnerRepo();
-      var labelSection = document.getElementById('label-section');
-      var labelList = document.getElementById('label-list');
-      if (ownerInput.value && repoInput.value && validRepos[repoSelect.value]) {
-        labelList.innerHTML = '<span class="empty">Loading labels...</span>';
-        labelSection.style.display = 'block';
-        htmx.ajax('GET', '/issues/new/labels?owner=' + encodeURIComponent(ownerInput.value) + '&repo=' + encodeURIComponent(repoInput.value), {target: '#label-list', swap: 'innerHTML'});
-      } else {
-        labelSection.style.display = 'none';
-        labelList.innerHTML = '';
-      }
-    });
-
-    // Validate before HTMX submit.
-    document.getElementById('create-issue-form').addEventListener('htmx:configRequest', function(evt) {
-      splitOwnerRepo();
-      if (!ownerInput.value || !repoInput.value) {
-        evt.preventDefault();
-        formError.textContent = 'Please select a repository before submitting.';
-        formError.style.display = 'block';
-        return false;
-      }
-      if (!validRepos[repoSelect.value]) {
-        evt.preventDefault();
-        formError.textContent = 'Please select a valid repository from the list.';
-        formError.style.display = 'block';
-        return false;
-      }
-      formError.style.display = 'none';
-    });
-
-    // Show server-side errors inline on HTMX error responses.
-    document.getElementById('create-issue-form').addEventListener('htmx:responseError', function(evt) {
-      formError.textContent = evt.detail.xhr.responseText || 'An error occurred. Please try again.';
-      formError.style.display = 'block';
-    });
-  })();
 </script>
 {{end}}

internal/templates/dashboard.html

@@ -1,17 +1,6 @@
 {{define "content"}}
 <h1>Dashboard</h1>
 
-{{if gt (len .Orgs) 1}}
-<div class="filter-bar">
-  <select name="org" hx-get="/" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
-    <option value="">All orgs</option>
-    {{range .Orgs}}
-    <option value="{{.}}" {{if eq . $.SelectedOrg}}selected{{end}}>{{.}}</option>
-    {{end}}
-  </select>
-</div>
-{{end}}
-
 {{if .Error}}
 <p class="empty">{{.Error}}</p>
 {{else if not .Items}}

internal/templates/issue_detail.html

@@ -3,15 +3,7 @@
 
 <div class="card">
   <div class="card-meta">
-    <span id="state-section">
-      {{if eq .Issue.State "closed"}}
-      <span class="state-closed" id="issue-state">{{.Issue.State}}</span>
-      <button class="btn btn-secondary" hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/state" hx-vals='{"state":"open"}' hx-target="#state-section" hx-swap="innerHTML">Reopen Issue</button>
-      {{else}}
-      <span class="state-open" id="issue-state">{{.Issue.State}}</span>
-      <button class="btn btn-danger" hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/state" hx-vals='{"state":"closed"}' hx-target="#state-section" hx-swap="innerHTML">Close Issue</button>
-      {{end}}
-    </span>
+    <span class="state-open">{{.Issue.State}}</span>
     <span>{{.Issue.RepoOwner}}/{{.Issue.RepoName}} #{{.Issue.Number}}</span>
     {{range .Issue.Labels}}
     <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
@@ -26,7 +18,6 @@
 
 {{if .Comments}}
 <h2>Comments</h2>
-<div id="comments-list">
 {{range .Comments}}
 <div class="comment">
   <div class="comment-header">
@@ -36,33 +27,10 @@
   <div class="comment-body">{{.Body}}</div>
 </div>
 {{end}}
-</div>
-{{else}}
-<div id="comments-list"></div>
 {{end}}
 
-<div class="card" style="margin-top:1rem;">
-  <h2>Add Comment</h2>
-  <form hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/comments" hx-target="#comments-list" hx-swap="beforeend" hx-on::after-request="if(event.detail.successful) this.reset()">
-    <textarea name="body" rows="4" placeholder="Write a comment..." required style="width:100%;margin-bottom:0.5rem;"></textarea>
-    <button type="submit" class="btn btn-primary" style="width:auto;padding:0.5rem 1rem;">Comment</button>
-  </form>
-</div>
-
 <div class="card" style="margin-top:1rem;">
   <h2>Actions</h2>
-  {{if .Collaborators}}
-  <form hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/assignees" hx-swap="outerHTML" style="margin-bottom:0.5rem;">
-    <div class="filter-bar" style="margin-bottom:0.5rem;">
-      <select name="assignee">
-        {{range .Collaborators}}
-        <option value="{{.}}">{{.}}</option>
-        {{end}}
-      </select>
-      <button type="submit" class="btn btn-secondary" style="width:auto;padding:0.5rem 1rem;">Assign</button>
-    </div>
-  </form>
-  {{end}}
   <form hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/labels" hx-swap="outerHTML" style="margin-bottom:0.5rem;">
     <div class="filter-bar" style="margin-bottom:0.5rem;">
       <select name="label_id">

internal/templates/issues.html

@@ -1,4 +1,25 @@
-{{define "cards"}}
+{{define "content"}}
+<h1>Issues</h1>
+
+<div class="filter-bar">
+  <select name="org" hx-get="/issues" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true" hx-include="[name='state']">
+    <option value="">All orgs</option>
+    {{range .Orgs}}
+    <option value="{{.}}" {{if eq . $.SelectedOrg}}selected{{end}}>{{.}}</option>
+    {{end}}
+  </select>
+  <select name="state" hx-get="/issues" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true" hx-include="[name='org']">
+    <option value="open" {{if eq .SelectedState "open"}}selected{{end}}>Open</option>
+    <option value="closed" {{if eq .SelectedState "closed"}}selected{{end}}>Closed</option>
+  </select>
+</div>
+
+{{if .Error}}
+<p class="empty">{{.Error}}</p>
+{{else if not .Issues}}
+<p class="empty">No issues found.</p>
+{{else}}
+<div id="issue-list">
   {{range .Issues}}
   <div class="card" hx-get="/issues/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
     <div class="card-title">{{.Title}}</div>
@@ -14,44 +35,10 @@
   </div>
   {{end}}
   {{if .HasMore}}
-  <div class="scroll-sentinel" hx-get="/issues?page={{.NextPage}}&org={{.SelectedOrg}}&state={{.SelectedState}}&label={{.SelectedLabel}}&repo={{.SelectedRepo}}" hx-trigger="revealed" hx-swap="outerHTML" hx-target="this">
+  <div class="scroll-sentinel" hx-get="/issues?page={{.NextPage}}&org={{.SelectedOrg}}&state={{.SelectedState}}" hx-trigger="revealed" hx-swap="outerHTML" hx-target="this">
     <div class="spinner htmx-indicator"></div>
   </div>
   {{end}}
-{{end}}
-
-{{define "content"}}
-<h1>Issues</h1>
-
-<div class="filter-bar">
-  <select name="org" hx-get="/issues" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true" hx-include="[name='state'],[name='label']">
-    <option value="">All orgs</option>
-    {{range .Orgs}}
-    <option value="{{.}}" {{if eq . $.SelectedOrg}}selected{{end}}>{{.}}</option>
-    {{end}}
-  </select>
-  {{if .Repos}}
-  <select name="repo" hx-get="/issues" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true" hx-include="[name='org'],[name='state'],[name='label']">
-    <option value="">All repos</option>
-    {{range .Repos}}<option value="{{.}}" {{if eq . $.SelectedRepo}}selected{{end}}>{{.}}</option>{{end}}
-  </select>
-  {{end}}
-  <select name="state" hx-get="/issues" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true" hx-include="[name='org'],[name='repo'],[name='label']">
-    <option value="open" {{if eq .SelectedState "open"}}selected{{end}}>Open</option>
-    <option value="closed" {{if eq .SelectedState "closed"}}selected{{end}}>Closed</option>
-  </select>
-  <input type="text" name="label" placeholder="Filter by label..." value="{{.SelectedLabel}}"
-         hx-get="/issues" hx-trigger="input changed delay:400ms" hx-target="#main-content"
-         hx-swap="innerHTML" hx-push-url="true" hx-include="[name='org'],[name='state'],[name='repo']">
-</div>
-
-{{if .Error}}
-<p class="empty">{{.Error}}</p>
-{{else if not .Issues}}
-<p class="empty">No issues found.</p>
-{{else}}
-<div id="issue-list">
-  {{template "cards" .}}
 </div>
 {{end}}
 {{end}}

internal/templates/layout.html

@@ -13,10 +13,6 @@
   <script src="/static/htmx.min.js"></script>
 </head>
 <body>
-  <header class="top-bar">
-    <span class="top-bar-title">Gitea Mobile</span>
-    <button class="refresh-btn" hx-get="" hx-target="#main-content" hx-swap="innerHTML" aria-label="Refresh">&#8635;</button>
-  </header>
   <div class="content" id="main-content">
     {{template "content" .}}
   </div>

internal/templates/pull_detail.html

@@ -4,7 +4,7 @@
 <div class="card">
   <div class="card-meta">
     <span class="type-badge type-pull">PR</span>
-    {{if eq .Pull.State "closed"}}<span class="state-closed">{{.Pull.State}}</span>{{else}}<span class="state-open">{{.Pull.State}}</span>{{end}}
+    <span class="state-open">{{.Pull.State}}</span>
     <span>{{.Pull.RepoOwner}}/{{.Pull.RepoName}} #{{.Pull.Number}}</span>
     {{range .Pull.Labels}}
     <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
@@ -15,17 +15,6 @@
     <span class="diff-del">-{{.Pull.Deletions}}</span>
     {{if .Pull.Mergeable}}<span style="color:var(--accent-green);">Mergeable</span>{{end}}
   </div>
-  <div class="card-meta" style="margin-top:0.5rem;">
-    <span id="state-section">
-      {{if eq .Pull.State "closed"}}
-      <span class="state-closed" id="pull-state">{{.Pull.State}}</span>
-      <button class="btn btn-secondary" hx-post="/pulls/{{.Pull.RepoOwner}}/{{.Pull.RepoName}}/{{.Pull.Number}}/state" hx-vals='{"state":"open"}' hx-target="#state-section" hx-swap="innerHTML">Reopen PR</button>
-      {{else}}
-      <span class="state-open" id="pull-state">{{.Pull.State}}</span>
-      <button class="btn btn-danger" hx-post="/pulls/{{.Pull.RepoOwner}}/{{.Pull.RepoName}}/{{.Pull.Number}}/state" hx-vals='{"state":"closed"}' hx-target="#state-section" hx-swap="innerHTML">Close PR</button>
-      {{end}}
-    </span>
-  </div>
   {{if .RenderedBody}}
   <div class="card-body markdown-body">{{.RenderedBody}}</div>
   {{else if .Pull.Body}}
@@ -57,21 +46,4 @@
     <button type="submit" class="btn btn-primary">Submit Review</button>
   </form>
 </div>
-
-{{if .Comments}}
-<h2>Comments</h2>
-<div id="comments-list">
-{{range .Comments}}
-<div class="comment">
-  <div class="comment-header">
-    <strong>{{.User}}</strong>
-    <span>{{.CreatedAt}}</span>
-  </div>
-  <div class="comment-body">{{.Body}}</div>
-</div>
-{{end}}
-</div>
-{{else}}
-<p class="empty" style="margin-top:1rem;">No comments yet.</p>
-{{end}}
 {{end}}

internal/templates/pulls.html

@@ -1,4 +1,21 @@
-{{define "cards"}}
+{{define "content"}}
+<h1>Pull Requests</h1>
+
+<div class="filter-bar">
+  <select name="org" hx-get="/pulls" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
+    <option value="">All orgs</option>
+    {{range .Orgs}}
+    <option value="{{.}}" {{if eq . $.SelectedOrg}}selected{{end}}>{{.}}</option>
+    {{end}}
+  </select>
+</div>
+
+{{if .Error}}
+<p class="empty">{{.Error}}</p>
+{{else if not .Pulls}}
+<p class="empty">No open pull requests found.</p>
+{{else}}
+<div id="pull-list">
   {{range .Pulls}}
   <div class="card" hx-get="/pulls/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
     <div class="card-title">
@@ -16,45 +33,6 @@
     </div>
   </div>
   {{end}}
-  {{if .HasMore}}
-  <div class="scroll-sentinel" hx-get="/pulls?page={{.NextPage}}&org={{.SelectedOrg}}&state={{.SelectedState}}&label={{.SelectedLabel}}&repo={{.SelectedRepo}}" hx-trigger="revealed" hx-swap="outerHTML" hx-target="this">
-    <div class="spinner htmx-indicator"></div>
-  </div>
-  {{end}}
-{{end}}
-
-{{define "content"}}
-<h1>Pull Requests</h1>
-
-<div class="filter-bar">
-  <select name="org" hx-get="/pulls" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true" hx-include="[name='state'],[name='label']">
-    <option value="">All orgs</option>
-    {{range .Orgs}}
-    <option value="{{.}}" {{if eq . $.SelectedOrg}}selected{{end}}>{{.}}</option>
-    {{end}}
-  </select>
-  {{if .Repos}}
-  <select name="repo" hx-get="/pulls" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true" hx-include="[name='org'],[name='state'],[name='label']">
-    <option value="">All repos</option>
-    {{range .Repos}}<option value="{{.}}" {{if eq . $.SelectedRepo}}selected{{end}}>{{.}}</option>{{end}}
-  </select>
-  {{end}}
-  <select name="state" hx-get="/pulls" hx-trigger="change" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true" hx-include="[name='org'],[name='repo'],[name='label']">
-    <option value="open" {{if eq .SelectedState "open"}}selected{{end}}>Open</option>
-    <option value="closed" {{if eq .SelectedState "closed"}}selected{{end}}>Closed</option>
-  </select>
-  <input type="text" name="label" placeholder="Filter by label..." value="{{.SelectedLabel}}"
-         hx-get="/pulls" hx-trigger="input changed delay:400ms" hx-target="#main-content"
-         hx-swap="innerHTML" hx-push-url="true" hx-include="[name='org'],[name='state'],[name='repo']">
-</div>
-
-{{if .Error}}
-<p class="empty">{{.Error}}</p>
-{{else if not .Pulls}}
-<p class="empty">No {{.SelectedState}} pull requests found.</p>
-{{else}}
-<div id="pull-list">
-  {{template "cards" .}}
 </div>
 {{end}}
 {{end}}

static/style.css

@@ -47,53 +47,10 @@ body {
   -moz-osx-font-smoothing: grayscale;
 }
 
-/* Top bar */
-.top-bar {
-  position: sticky;
-  top: 0;
-  z-index: 100;
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: var(--spacing-sm) var(--spacing-lg);
-  padding-top: max(var(--spacing-sm), env(safe-area-inset-top));
-  background: var(--bg-secondary);
-  border-bottom: 1px solid var(--border);
-}
-
-.top-bar-title {
-  font-size: var(--font-base);
-  font-weight: 600;
-  color: var(--text-primary);
-}
-
-.refresh-btn {
-  background: none;
-  border: none;
-  color: var(--text-secondary);
-  font-size: 1.4rem;
-  padding: var(--spacing-xs) var(--spacing-sm);
-  cursor: pointer;
-  -webkit-tap-highlight-color: transparent;
-  line-height: 1;
-  border-radius: var(--radius-sm);
-  transition: color 0.15s ease, background 0.15s ease;
-}
-
-.refresh-btn:active {
-  color: var(--accent-blue);
-  background: var(--bg-tertiary);
-}
-
-.refresh-btn.htmx-request {
-  animation: spin 0.6s linear infinite;
-  pointer-events: none;
-}
-
 /* Content area */
 .content {
   padding: var(--spacing-lg);
-  padding-top: var(--spacing-lg);
+  padding-top: max(var(--spacing-lg), env(safe-area-inset-top));
   max-width: 640px;
   margin: 0 auto;
 }