Address non-inline PR comments in the watcher loop

Previously the PR lifecycle only fetched inline review comments
(pulls/{n}/comments). General issue-level PR comments and the free-text
body of review submissions were either ignored or stored but never
surfaced to Claude, so whole classes of reviewer feedback went
unanswered.

The pr_comments table now carries a `kind` column (inline | issue |
review_summary) with a composite unique index on (kind,
github_comment_id) since those IDs come from different server-side
tables and can collide. Migration 22 also stamps a
pr_comments_rollout_cutoff timestamp so existing active PRs don't get
retroactively reworked — any source comment older than the cutoff is
inserted as already-addressed.

The service now pulls all three sources in each tick:
  - listPrComments  → kind=inline (existing behavior)
  - listIssueComments → kind=issue (new)
  - synthesized per review with non-empty body → kind=review_summary

Bot-authored issue-comment replies carry a hidden `<!-- sustn:task=... -->`
marker so they're filtered out on the next fetch without needing to
resolve the gh user's login (robust against auth swaps).

Each item sent to Claude is tagged [KIND: ...] in addition to the
existing COMMENT_ID tag; the reply JSON requires `kind` echoed back so
we can route inline replies to the pull-comment replies endpoint and
issue / review-summary replies to a new top-level issue comment. The
resolved-threads filter is now scoped to kind=inline to avoid dropping
issue rows whose ID coincidentally equals a resolved inline thread's
root ID.

Author: Ghvstcode

src-tauri/src/engine_commands.rs

@@ -855,42 +855,48 @@ pub async fn engine_address_review(
     let prompt = format!(
         r#"IMPORTANT: You are running as an automated background agent in non-interactive mode. Commit your changes directly — do NOT ask for permission.
 
-A human reviewer has left comments on a PR. You need to handle EVERY comment — either by making code changes or by drafting a reply.
+A human reviewer has left feedback on a PR. You need to handle EVERY item — either by making code changes or by drafting a reply.
 
 ## PR Description
 {pr_description}
 {pr_context_section}
-## Review Comments
-Each comment below has a COMMENT_ID number that you MUST include in your response.
+## Review Items
+Each item below has a COMMENT_ID and a KIND tag that you MUST echo back in your response.
+
+KIND values and what they mean:
+- `inline` — a review comment anchored to a specific diff line. Usually narrow and code-specific.
+- `issue` — a general PR comment not tied to a line. May be a question, a request, or plain chat. Not all of them need a code change — sometimes a plain reply is correct.
+- `review_summary` — the free-text body a reviewer wrote when submitting a review. Often contains overall asks (e.g. "please split this into two PRs", "looks good but rename X") that complement the per-line comments in the same review. Treat these as first-class feedback.
 
 {review_comments}
 {prefs_section}
 
 ## Instructions
-For EACH review comment above:
+For EACH item above:
 
-1. **If it requires code changes** (bug fix, refactor, improvement, the reviewer is questioning an approach and they're right): make the changes, commit with trailer SUSTN-Task: {task_id}, and draft a reply explaining what you changed.
+1. **If it requires code changes** (bug fix, refactor, improvement, a legitimate concern about the approach): make the changes, commit with trailer SUSTN-Task: {task_id}, and draft a reply explaining what you changed.
 
 2. **If it's a question about your reasoning** (why did you do X?): explain your reasoning clearly — you have context from when you wrote this code.
 
-3. **If it's praise or acknowledgment** (looks good, nice, etc.): draft a brief thanks.
+3. **If it's conversational** (praise, a check-in, a "what do you think about Y?"): draft a brief, appropriate reply. No code change needed.
 
-CRITICAL: You MUST return a reply for EVERY comment. Use the exact COMMENT_ID number from each comment header above.
+CRITICAL: You MUST return a reply for EVERY item. Use the exact COMMENT_ID number and KIND value from the header above each item.
 
 After making any code changes and committing, output ONLY this JSON (no markdown):
 {{
   "replies": [
     {{
       "comment_id": 1234567890,
-      "reply": "Your response to this specific comment",
+      "kind": "inline",
+      "reply": "Your response to this specific item",
       "made_code_changes": true
     }}
   ],
   "summary": "Brief description of what was changed",
   "files_modified": ["list", "of", "files"]
 }}
 
-The comment_id MUST be the numeric ID from the [COMMENT_ID: <number>] tag in each comment above. Do NOT use null."#
+The comment_id MUST be the numeric ID from the [COMMENT_ID: <number>] tag. The kind MUST be one of `inline`, `issue`, or `review_summary` matching the [KIND: ...] tag. Do NOT use null for either field."#
     );
 
     // Create/reuse worktree for task isolation

src-tauri/src/migrations.rs

@@ -411,5 +411,22 @@ pub fn migrations() -> Vec<Migration> {
             "#,
             kind: MigrationKind::Up,
         },
+        // Migration 22: track comment source kind so issue-level and
+        // review-summary comments live alongside inline review comments
+        // without colliding on github_comment_id (different server-side
+        // ID namespaces can reuse the same integer).
+        Migration {
+            version: 22,
+            description: "add kind to pr_comments and seed rollout cutoff",
+            sql: r#"
+                ALTER TABLE pr_comments ADD COLUMN kind TEXT NOT NULL DEFAULT 'inline';
+                DROP INDEX IF EXISTS idx_pr_comments_github_id;
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_pr_comments_kind_github_id
+                    ON pr_comments(kind, github_comment_id);
+                INSERT OR IGNORE INTO global_settings (key, value) VALUES
+                    ('pr_comments_rollout_cutoff', strftime('%Y-%m-%dT%H:%M:%fZ', 'now'));
+            "#,
+            kind: MigrationKind::Up,
+        },
     ]
 }

src/core/db/pr-lifecycle.ts

@@ -6,7 +6,7 @@
 import Database from "@tauri-apps/plugin-sql";
 import { invoke } from "@tauri-apps/api/core";
 import { config } from "@core/config";
-import type { PrReview, PrComment } from "@core/types/task";
+import type { PrReview, PrComment, PrCommentKind } from "@core/types/task";
 
 async function getDb() {
     return await Database.load(config.dbUrl);
@@ -114,6 +114,7 @@ interface PrCommentRow {
     id: string;
     task_id: string;
     github_comment_id: number;
+    kind: string;
     in_reply_to_id: number | null;
     reviewer: string;
     body: string;
@@ -133,6 +134,7 @@ function rowToComment(row: PrCommentRow): PrComment {
         id: row.id,
         taskId: row.task_id,
         githubCommentId: row.github_comment_id,
+        kind: (row.kind as PrCommentKind) ?? "inline",
         inReplyToId: row.in_reply_to_id ?? undefined,
         reviewer: row.reviewer,
         body: row.body,
@@ -153,53 +155,64 @@ export async function upsertComment(
     taskId: string,
     comment: {
         githubCommentId: number;
+        kind: PrCommentKind;
         inReplyToId?: number;
         reviewer: string;
         body: string;
         path?: string;
         line?: number;
         side?: string;
         commitId?: string;
+        /**
+         * When the source comment predates the non-inline-comment rollout,
+         * the service passes a commit-sha-like sentinel so the row is
+         * inserted as already-addressed and never re-sent to Claude.
+         */
+        preAddressedSentinel?: string;
     },
 ): Promise<PrComment> {
     const db = await getDb();
 
-    // Check if already exists — update body if so
+    // Check if already exists — match on (kind, github_comment_id) because
+    // review / pull-comment / issue-comment IDs share an integer space but
+    // come from different server-side tables and can collide.
     const existing = await db.select<PrCommentRow[]>(
-        "SELECT * FROM pr_comments WHERE github_comment_id = $1",
-        [comment.githubCommentId],
+        "SELECT * FROM pr_comments WHERE kind = $1 AND github_comment_id = $2",
+        [comment.kind, comment.githubCommentId],
     );
 
     if (existing.length > 0) {
-        // Update body in case it changed
         if (existing[0].body !== comment.body) {
             await db.execute(
-                "UPDATE pr_comments SET body = $1, updated_at = CURRENT_TIMESTAMP WHERE github_comment_id = $2",
-                [comment.body, comment.githubCommentId],
+                "UPDATE pr_comments SET body = $1, updated_at = CURRENT_TIMESTAMP WHERE kind = $2 AND github_comment_id = $3",
+                [comment.body, comment.kind, comment.githubCommentId],
             );
         }
         const rows = await db.select<PrCommentRow[]>(
-            "SELECT * FROM pr_comments WHERE github_comment_id = $1",
-            [comment.githubCommentId],
+            "SELECT * FROM pr_comments WHERE kind = $1 AND github_comment_id = $2",
+            [comment.kind, comment.githubCommentId],
         );
         return rowToComment(rows[0]);
     }
 
     const id = await invoke<string>("generate_task_id");
     await db.execute(
-        `INSERT INTO pr_comments (id, task_id, github_comment_id, in_reply_to_id, reviewer, body, path, line, side, commit_id)
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+        `INSERT INTO pr_comments (id, task_id, github_comment_id, kind, in_reply_to_id, reviewer, body, path, line, side, commit_id, addressed_in_commit, classification)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`,
         [
             id,
             taskId,
             comment.githubCommentId,
+            comment.kind,
             comment.inReplyToId ?? null,
             comment.reviewer,
             comment.body,
             comment.path ?? null,
             comment.line ?? null,
             comment.side ?? null,
             comment.commitId ?? null,
+            comment.preAddressedSentinel ?? null,
+            comment.preAddressedSentinel ? "resolved" : null,
         ],
     );
 
@@ -245,27 +258,44 @@ export async function updateCommentClassification(
 }
 
 export async function markCommentAddressed(
+    kind: PrCommentKind,
     githubCommentId: number,
     commitSha: string,
 ): Promise<void> {
     const db = await getDb();
     await db.execute(
-        "UPDATE pr_comments SET addressed_in_commit = $1, classification = 'resolved', updated_at = CURRENT_TIMESTAMP WHERE github_comment_id = $2",
-        [commitSha, githubCommentId],
+        "UPDATE pr_comments SET addressed_in_commit = $1, classification = 'resolved', updated_at = CURRENT_TIMESTAMP WHERE kind = $2 AND github_comment_id = $3",
+        [commitSha, kind, githubCommentId],
     );
 }
 
 export async function setCommentReply(
+    kind: PrCommentKind,
     githubCommentId: number,
     reply: string,
 ): Promise<void> {
     const db = await getDb();
     await db.execute(
-        "UPDATE pr_comments SET our_reply = $1, updated_at = CURRENT_TIMESTAMP WHERE github_comment_id = $2",
-        [reply, githubCommentId],
+        "UPDATE pr_comments SET our_reply = $1, updated_at = CURRENT_TIMESTAMP WHERE kind = $2 AND github_comment_id = $3",
+        [reply, kind, githubCommentId],
     );
 }
 
+/**
+ * Read the rollout cutoff timestamp stamped at migration 22 install time.
+ * Comments/reviews with source timestamp <= cutoff are treated as
+ * pre-existing history and not fed back to Claude.
+ */
+export async function getPrCommentsRolloutCutoff(): Promise<
+    string | undefined
+> {
+    const db = await getDb();
+    const rows = await db.select<{ value: string }[]>(
+        "SELECT value FROM global_settings WHERE key = 'pr_comments_rollout_cutoff'",
+    );
+    return rows[0]?.value;
+}
+
 /** Get all tasks that have an active PR lifecycle (for polling) */
 export async function getTasksWithActivePr(): Promise<
     {

src/core/services/github.ts

@@ -30,6 +30,15 @@ export interface GhPrComment {
     updated_at: string;
 }
 
+/** Issue-level comment on a PR (general discussion, not tied to a line). */
+export interface GhIssueComment {
+    id: number;
+    user: { login: string };
+    body: string;
+    created_at: string;
+    updated_at: string;
+}
+
 export interface GhPrStatus {
     state: "open" | "closed" | "merged";
     merged: boolean;
@@ -185,6 +194,57 @@ export async function postPrComment(
     );
 }
 
+// ── Issue-level Comments ────────────────────────────────────
+
+/**
+ * List issue-level comments on a PR (general conversation, not tied to a
+ * diff line). These come from the issues endpoint because PRs are issues
+ * on the GitHub data model.
+ */
+export async function listIssueComments(
+    repoPath: string,
+    owner: string,
+    repo: string,
+    prNumber: number,
+): Promise<GhIssueComment[]> {
+    return ghApi<GhIssueComment[]>(
+        repoPath,
+        `repos/${owner}/${repo}/issues/${prNumber}/comments`,
+    );
+}
+
+/**
+ * Marker appended to every bot-authored issue comment so we can identify
+ * and skip them on the next fetch, without having to resolve the gh
+ * user's login. More robust than login matching if auth is swapped.
+ */
+export const SUSTN_MARKER_PREFIX = "<!-- sustn:task=";
+
+export function sustnMarker(taskId: string): string {
+    return `${SUSTN_MARKER_PREFIX}${taskId} -->`;
+}
+
+export function bodyHasSustnMarker(body: string): boolean {
+    return body.includes(SUSTN_MARKER_PREFIX);
+}
+
+/**
+ * Post an issue comment on a PR with a trailing marker identifying it as
+ * authored by SUSTN for a given task. The marker is invisible in GitHub's
+ * rendered markdown but lets us dedup on fetch.
+ */
+export async function postPrCommentWithMarker(
+    repoPath: string,
+    owner: string,
+    repo: string,
+    prNumber: number,
+    taskId: string,
+    body: string,
+): Promise<{ id: number }> {
+    const stamped = `${body}\n\n${sustnMarker(taskId)}`;
+    return postPrComment(repoPath, owner, repo, prNumber, stamped);
+}
+
 // ── Re-request Review ───────────────────────────────────────
 
 export async function requestReview(