diff --git a/CHANGELOG.md b/CHANGELOG.md
index bda27993..71d4af2a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,8 +9,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **PR Review 2.0** — a chantier of composable, keyboard-first review upgrades:
+  - **GitHub-standard review keymap** — `J`/`K` next/previous hunk, `⇧J`/`⇧K` next/previous file, `V` toggle viewed, `⇧V` hide viewed files, `T` filter files, `C` comment on the current hunk, `N`/`P` next/previous AI finding, `⌘Enter`/`Ctrl+Enter` submit review. Documented in Help → Keyboard Shortcuts.
+  - **Viewed-file state** — mark files as reviewed; hidden-viewed-files view to focus on what's left. Invalidated at the whole-PR level when the head SHA changes (a re-push resets viewed state honestly, rather than silently keeping stale marks).
+  - **Pending review surfaced** — draft review comments persist across closing/reopening the PR detail (survives navigating away) and are visible as a running count before submission.
+  - **Dismiss review / request reviewers** — GitHub gains both actions from the Info tab; forges that don't support one (e.g. GitLab has no direct review-dismissal equivalent) hide the action instead of throwing.
+  - **Local, opt-in AI pre-review pipeline** — a multi-hop pass (diff → import/dependency extraction → file history → LLM findings) surfaces confidence-scored, line-anchored findings with a cap and per-finding dismissal memory. Zero calls when the setting is off; a PR switch aborts any in-flight run. Configurable under Settings → Git → Review AI.
+  - **PR summary block** — a generated one-paragraph summary of the PR's intent and risk, shown above the diff, regeneratable on demand.
+  - **Unified `LineAnnotation` model** — CI check-run annotations, AI findings, and static heuristic flags now render through one merged gutter-overlay stream instead of three separate code paths.
+  - **GitLab real review completion** — inline batch review comments anchor correctly via a dedicated diff-refs lookup, `listReviews` reflects approvals and changes-requested verdicts, and file review history reports real per-path comment counts.
 - **Pre-commit secrets scanner** — a zero-network, local scanner over the staged diff's added lines, detecting AWS/GCP/Azure/GitHub/GitLab/Slack/Stripe/OpenAI/Anthropic tokens, RSA/OpenSSH/EC/PGP private-key headers, JWTs, and high-entropy literals (Shannon entropy, tunable threshold). Non-blocking in-app: an orange badge in the commit area opens a findings modal (redacted excerpts only, per-finding dismiss, per-pattern ignore), and committing with active findings shows a confirm the user can always bypass. Extensible per-repo via `.gitwandrc` `secrets.patterns[]` / `secrets.ignore[]`. Dual-implemented (Rust `regex` crate for the desktop app, a pure TypeScript mirror in `@gitwand/core` for `pnpm dev:web` and the CLI) and locked in sync by a parity test. Also ships `gitwand scan [--json] [--strict]` in the CLI and an opt-in, blocking pre-commit hook installer (Settings → Hooks) that shells out to it — always bypassable with `git commit --no-verify`.
 
+### Changed
+
+- **PR detail open now costs 3 forge calls on the hot path (was 6)** — revalidation on reopening an already-cached PR detail was slimmed to only the calls that can actually have changed.
+- **PR diff parsing is lazy, per-file** — a PR with many changed files no longer parses every file's hunks up front; only the file currently open is parsed, cached by path.
+- **Diff line rendering is virtualized** — large diffs (thousands of lines) keep a bounded DOM instead of rendering every line, fixing scroll/interaction lag on big files.
+
+### Fixed
+
+- **Azure comment edit/delete no longer risks a runtime crash** — `updateComment`/`deleteComment` are unsupported on Azure DevOps for now; the UI hides the edit/delete affordance instead of calling into a forge method that throws.
+
 ## [3.4.0] - 2026-07-08
 
 ### Added
diff --git a/apps/desktop/dev-server.mjs b/apps/desktop/dev-server.mjs
index be4ca044..a3fd76bd 100644
--- a/apps/desktop/dev-server.mjs
+++ b/apps/desktop/dev-server.mjs
@@ -3234,6 +3234,7 @@ async function handleRequest(req, res) {
           reviewers: (pr.requested_reviewers ?? []).map((r) => r.login ?? ""),
           mergeable: pr.mergeable_state ?? "unknown",
           checks_status: "",
+          head_sha: pr.head?.sha ?? "",
         });
       } catch (err) {
         return jsonResponse(req, res, { error: err.stderr?.toString() || err.message }, 500);
@@ -4450,6 +4451,64 @@ async function handleRequest(req, res) {
       }
     }
 
+    // POST /api/gh-dismiss-review  { cwd, number, reviewId, message } (B4, v3.6.0)
+    if (url.pathname === "/api/gh-dismiss-review" && req.method === "POST") {
+      try {
+        const { cwd, number, reviewId, message } = await readBody(req);
+        if (!cwd || !number || !reviewId) return jsonResponse(req, res, { error: "Missing cwd, number, or reviewId" }, 400);
+        const token = getGithubToken();
+        if (!token) return jsonResponse(req, res, { error: "No GitHub token" }, 401);
+        const nwo = getRepoNwo(resolve(cwd));
+        if (!nwo) return jsonResponse(req, res, { error: "Could not determine GitHub repo" }, 400);
+        const resp = await fetch(`https://api.github.com/repos/${nwo}/pulls/${number}/reviews/${reviewId}/dismissals`, {
+          method: "PUT",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ message: message || "", event: "DISMISS" }),
+        });
+        if (!resp.ok) {
+          const body = await resp.text().catch(() => "");
+          return jsonResponse(req, res, { error: `GitHub API ${resp.status}${body ? `: ${body}` : ""}` }, 500);
+        }
+        return jsonResponse(req, res, { ok: true });
+      } catch (err) {
+        return jsonResponse(req, res, { error: err.stderr?.toString() || err.message }, 500);
+      }
+    }
+
+    // POST /api/gh-request-reviewers  { cwd, number, logins } (B4, v3.6.0)
+    if (url.pathname === "/api/gh-request-reviewers" && req.method === "POST") {
+      try {
+        const { cwd, number, logins } = await readBody(req);
+        if (!cwd || !number || !Array.isArray(logins)) return jsonResponse(req, res, { error: "Missing cwd, number, or logins" }, 400);
+        const token = getGithubToken();
+        if (!token) return jsonResponse(req, res, { error: "No GitHub token" }, 401);
+        const nwo = getRepoNwo(resolve(cwd));
+        if (!nwo) return jsonResponse(req, res, { error: "Could not determine GitHub repo" }, 400);
+        const resp = await fetch(`https://api.github.com/repos/${nwo}/pulls/${number}/requested_reviewers`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ reviewers: logins }),
+        });
+        if (!resp.ok) {
+          const body = await resp.text().catch(() => "");
+          return jsonResponse(req, res, { error: `GitHub API ${resp.status}${body ? `: ${body}` : ""}` }, 500);
+        }
+        return jsonResponse(req, res, { ok: true });
+      } catch (err) {
+        return jsonResponse(req, res, { error: err.stderr?.toString() || err.message }, 500);
+      }
+    }
+
     // POST /api/git-interactive-rebase  { cwd, base, todoLines }
     // Starts an interactive rebase with a custom todo list.
     // Writes a temp file and uses GIT_SEQUENCE_EDITOR to inject it.
diff --git a/apps/desktop/src-tauri/src/commands/azure.rs b/apps/desktop/src-tauri/src/commands/azure.rs
index b57aab11..4eaf81e5 100644
--- a/apps/desktop/src-tauri/src/commands/azure.rs
+++ b/apps/desktop/src-tauri/src/commands/azure.rs
@@ -586,6 +586,7 @@ fn json_to_detail(r: &AzureRepo, pr: &serde_json::Value) -> PullRequestDetail {
         // Azure merge permission needs the Security/Permissions API — not
         // cheaply available here. Unknown ⇒ UI gates on errors only.
         can_merge: None,
+        head_sha: jnested(pr, "lastMergeSourceCommit", "commitId"),
     }
 }
 
diff --git a/apps/desktop/src-tauri/src/commands/bitbucket.rs b/apps/desktop/src-tauri/src/commands/bitbucket.rs
index a9c337d6..3ea7e3d9 100644
--- a/apps/desktop/src-tauri/src/commands/bitbucket.rs
+++ b/apps/desktop/src-tauri/src/commands/bitbucket.rs
@@ -381,6 +381,7 @@ fn bb_pr_to_detail(pr: &serde_json::Value) -> PullRequestDetail {
         // Bitbucket merge permission needs a separate privileges call —
         // unknown ⇒ UI gates on errors only.
         can_merge: None,
+        head_sha: jdeep(pr, "source", "commit", "hash"),
     }
 }
 
diff --git a/apps/desktop/src-tauri/src/commands/gh.rs b/apps/desktop/src-tauri/src/commands/gh.rs
index 0fa45592..6a20224c 100644
--- a/apps/desktop/src-tauri/src/commands/gh.rs
+++ b/apps/desktop/src-tauri/src/commands/gh.rs
@@ -639,6 +639,56 @@ pub(crate) async fn gh_pr_ready(cwd: String, number: i64) -> Result<(), String>
         .map_err(|e| e.to_string())?
 }
 
+fn gh_dismiss_review_inner(cwd: String, number: i64, review_id: i64, message: String) -> Result<(), String> {
+    if let Some(tok) = github_api::settings_github_token() {
+        return github_api::rest_dismiss_review(&cwd, number, review_id, &message, &tok);
+    }
+    let nwo = gh_fork_upstream(&cwd).unwrap_or_else(|| "{owner}/{repo}".to_string());
+    let path = format!("repos/{}/pulls/{}/reviews/{}/dismissals", nwo, number, review_id);
+    gh_api_write(&cwd, "PUT", &path, &[("message", message.as_str()), ("event", "DISMISS")])?;
+    Ok(())
+}
+
+/// Dismiss a submitted review (B4, v3.6.0).
+#[tauri::command]
+pub(crate) async fn gh_dismiss_review(cwd: String, number: i64, review_id: i64, message: String) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || gh_dismiss_review_inner(cwd, number, review_id, message))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
+fn gh_request_reviewers_inner(cwd: String, number: i64, logins: Vec<String>) -> Result<(), String> {
+    if let Some(tok) = github_api::settings_github_token() {
+        return github_api::rest_request_reviewers(&cwd, number, &logins, &tok);
+    }
+    let nwo = gh_fork_upstream(&cwd).unwrap_or_else(|| "{owner}/{repo}".to_string());
+    let path = format!("repos/{}/pulls/{}/requested_reviewers", nwo, number);
+    let mut cmd = hidden_cmd("gh");
+    cmd.args(["api", "-X", "POST", &path]);
+    for login in &logins {
+        cmd.args(["-f", &format!("reviewers[]={}", login)]);
+    }
+    let output = cmd
+        .current_dir(&cwd)
+        .output()
+        .map_err(|e| format!("gh api request reviewers: {}", e))?;
+    if !output.status.success() {
+        return Err(format!(
+            "gh api request reviewers failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        ));
+    }
+    Ok(())
+}
+
+/// Request reviewers on an existing PR (B4, v3.6.0).
+#[tauri::command]
+pub(crate) async fn gh_request_reviewers(cwd: String, number: i64, logins: Vec<String>) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || gh_request_reviewers_inner(cwd, number, logins))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
 fn gh_pr_detail_inner(cwd: String, number: i64) -> Result<PullRequestDetail, String> {
     if let Some(tok) = github_api::settings_github_token() {
         return github_api::rest_pr_detail(&cwd, number, &tok);
@@ -648,7 +698,7 @@ fn gh_pr_detail_inner(cwd: String, number: i64) -> Result<PullRequestDetail, Str
     let mut cmd = hidden_cmd("gh");
     cmd.args([
         "pr", "view", &num,
-        "--json", "number,title,body,state,author,headRefName,baseRefName,isDraft,createdAt,updatedAt,mergedAt,url,additions,deletions,changedFiles,comments,reviewRequests,labels,reviews,mergeable,statusCheckRollup",
+        "--json", "number,title,body,state,author,headRefName,headRefOid,baseRefName,isDraft,createdAt,updatedAt,mergedAt,url,additions,deletions,changedFiles,comments,reviewRequests,labels,reviews,mergeable,statusCheckRollup",
     ]);
     if let Some(ref nwo) = upstream {
         cmd.args(["--repo", nwo]);
diff --git a/apps/desktop/src-tauri/src/commands/github_api.rs b/apps/desktop/src-tauri/src/commands/github_api.rs
index 01617c5c..8f09445c 100644
--- a/apps/desktop/src-tauri/src/commands/github_api.rs
+++ b/apps/desktop/src-tauri/src/commands/github_api.rs
@@ -385,6 +385,7 @@ fn json_to_detail(pr: &serde_json::Value) -> PullRequestDetail {
         // Filled in by rest_pr_detail via an explicit repo lookup — the pulls
         // response does not embed `permissions` on the nested base repo.
         can_merge: None,
+        head_sha: jnested(pr, "head", "sha"),
     }
 }
 
@@ -1150,6 +1151,35 @@ pub(crate) fn rest_merge_pr(cwd: &str, number: i64, method: &str, token: &str) -
     Ok(())
 }
 
+/// Dismiss a submitted review (B4, v3.6.0).
+pub(crate) fn rest_dismiss_review(
+    cwd: &str,
+    number: i64,
+    review_id: i64,
+    message: &str,
+    token: &str,
+) -> Result<(), String> {
+    let (repo, _pr) = get_pr_json(cwd, number, token)?;
+    let url = format!("{}/repos/{}/pulls/{}/reviews/{}/dismissals", API_BASE, repo, number, review_id);
+    let payload = serde_json::json!({ "message": message, "event": "DISMISS" });
+    api_json("PUT", &url, token, Some(&payload.to_string()))?;
+    Ok(())
+}
+
+/// Request reviewers on an existing PR (B4, v3.6.0).
+pub(crate) fn rest_request_reviewers(
+    cwd: &str,
+    number: i64,
+    logins: &[String],
+    token: &str,
+) -> Result<(), String> {
+    let (repo, _pr) = get_pr_json(cwd, number, token)?;
+    let url = format!("{}/repos/{}/pulls/{}/requested_reviewers", API_BASE, repo, number);
+    let payload = serde_json::json!({ "reviewers": logins });
+    api_json("POST", &url, token, Some(&payload.to_string()))?;
+    Ok(())
+}
+
 pub(crate) fn rest_pr_ready(cwd: &str, number: i64, token: &str) -> Result<(), String> {
     // Draft→ready is GraphQL-only; resolve the PR node_id first (origin or upstream).
     let (_repo, pr) = get_pr_json(cwd, number, token)?;
diff --git a/apps/desktop/src-tauri/src/commands/gitlab.rs b/apps/desktop/src-tauri/src/commands/gitlab.rs
index b09f0439..19a7ce91 100644
--- a/apps/desktop/src-tauri/src/commands/gitlab.rs
+++ b/apps/desktop/src-tauri/src/commands/gitlab.rs
@@ -188,6 +188,12 @@ fn gl_mr_to_detail(mr: &serde_json::Value) -> PullRequestDetail {
             .get("user")
             .and_then(|u| u.get("can_merge"))
             .and_then(|b| b.as_bool()),
+        head_sha: mr
+            .get("diff_refs")
+            .and_then(|d| d.get("head_sha"))
+            .and_then(|s| s.as_str())
+            .map(String::from)
+            .unwrap_or_else(|| js(mr, "sha")),
     }
 }
 
@@ -350,6 +356,37 @@ pub(crate) async fn gl_get_mr(cwd: String, iid: i64) -> Result<PullRequestDetail
     Ok(detail)
 }
 
+/// Get a MR's diff refs (F1, v3.6.0) — `base_sha`/`start_sha`/`head_sha`,
+/// required to correctly anchor inline discussion comments (old/new-side
+/// positioning) via the Discussions API. Same `glab mr view --output json`
+/// fetch pattern as `gl_mr_to_detail`.
+#[tauri::command]
+pub(crate) async fn gl_mr_diff_refs(cwd: String, iid: i64) -> Result<MrDiffRefs, String> {
+    let output = hidden_cmd("glab")
+        .args(["mr", "view", &iid.to_string(), "--output", "json"])
+        .current_dir(&cwd)
+        .output()
+        .map_err(|e| format!("glab mr view: {}", e))?;
+    if !output.status.success() {
+        return Err(format!(
+            "glab mr view failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        ));
+    }
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let mr: serde_json::Value = serde_json::from_str(stdout.trim())
+        .map_err(|e| format!("Failed to parse glab mr view output: {}", e))?;
+    let refs = mr.get("diff_refs").cloned().unwrap_or(serde_json::Value::Null);
+    let base_sha = js(&refs, "base_sha");
+    let start_sha = js(&refs, "start_sha");
+    let head_sha = js(&refs, "head_sha");
+    Ok(MrDiffRefs {
+        base_sha: base_sha.clone(),
+        start_sha: if start_sha.is_empty() { base_sha } else { start_sha },
+        head_sha: if head_sha.is_empty() { js(&mr, "sha") } else { head_sha },
+    })
+}
+
 /// Get the unified diff of a MR using `glab mr diff`.
 #[tauri::command]
 pub(crate) async fn gl_mr_diff(cwd: String, iid: i64) -> Result<String, String> {
@@ -1002,6 +1039,61 @@ pub(crate) async fn gl_reviewer_candidates(cwd: String) -> Result<Vec<ReviewerCa
     Ok(candidates)
 }
 
+/// Resolve a GitLab username to its numeric member id within the current
+/// project — the merge-request update endpoint takes `reviewer_ids`
+/// (numeric), not usernames.
+fn gl_resolve_member_id(cwd: &str, username: &str) -> Option<i64> {
+    let output = hidden_cmd("glab")
+        .args(["api", &format!("projects/:fullpath/members/all?query={}", username)])
+        .current_dir(cwd)
+        .output()
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let arr: serde_json::Value = serde_json::from_str(stdout.trim()).ok()?;
+    arr.as_array()?
+        .iter()
+        .find(|m| m.get("username").and_then(|v| v.as_str()) == Some(username))
+        .and_then(|m| m.get("id"))
+        .and_then(|v| v.as_i64())
+}
+
+/// Request reviewers on an existing MR (B4, v3.6.0) — `PUT
+/// /merge_requests/:iid` with `reviewer_ids[]=<id>` per resolved username.
+#[tauri::command]
+pub(crate) async fn gl_request_reviewers(cwd: String, iid: i64, usernames: Vec<String>) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let ids: Vec<i64> = usernames
+            .iter()
+            .filter_map(|u| gl_resolve_member_id(&cwd, u))
+            .collect();
+        if ids.is_empty() {
+            return Err("Could not resolve any reviewer username to a GitLab project member.".to_string());
+        }
+        let endpoint = format!("projects/:fullpath/merge_requests/{}", iid);
+        let mut cmd = hidden_cmd("glab");
+        cmd.args(["api", "-X", "PUT", &endpoint]);
+        for id in &ids {
+            cmd.args(["-f", &format!("reviewer_ids[]={}", id)]);
+        }
+        let output = cmd
+            .current_dir(&cwd)
+            .output()
+            .map_err(|e| format!("glab api request reviewers: {}", e))?;
+        if !output.status.success() {
+            return Err(format!(
+                "glab api request reviewers failed: {}",
+                String::from_utf8_lossy(&output.stderr)
+            ));
+        }
+        Ok(())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
 /// List branch names for the project via `glab api`. Paginated at 100/page,
 /// deduped, case-insensitively sorted. Non-fatal on failure (returns partial).
 #[tauri::command]
diff --git a/apps/desktop/src-tauri/src/git/parse.rs b/apps/desktop/src-tauri/src/git/parse.rs
index ea303bf5..0ee46447 100644
--- a/apps/desktop/src-tauri/src/git/parse.rs
+++ b/apps/desktop/src-tauri/src/git/parse.rs
@@ -435,6 +435,7 @@ pub(crate) fn gh_pr_detail_raw_to_detail(r: GhPrDetailRaw) -> PullRequestDetail
         // Filled in by the caller (gh_pr_detail) via a `gh repo view`
         // viewerPermission lookup — `gh pr view` doesn't carry it.
         can_merge: None,
+        head_sha: r.head_ref_oid,
     }
 }
 
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index ca8e43af..04985912 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -433,6 +433,8 @@ pub fn run() {
             commands::gh::gh_add_reaction,
             commands::gh::gh_delete_reaction,
             commands::gh::gh_pr_ready,
+            commands::gh::gh_dismiss_review,
+            commands::gh::gh_request_reviewers,
             commands::gh::gh_fork_info,
             commands::github_api::github_device_start,
             commands::github_api::github_device_poll,
@@ -533,6 +535,7 @@ pub fn run() {
             commands::gitlab::gl_list_issues,
             commands::gitlab::gl_mr_count,
             commands::gitlab::gl_get_mr,
+            commands::gitlab::gl_mr_diff_refs,
             commands::gitlab::gl_mr_diff,
             commands::gitlab::gl_mr_pipelines,
             commands::gitlab::gl_mr_annotations,
@@ -548,6 +551,7 @@ pub fn run() {
             commands::gitlab::gl_list_reviews,
             commands::gitlab::gl_current_user,
             commands::gitlab::gl_reviewer_candidates,
+            commands::gitlab::gl_request_reviewers,
             commands::gitlab::gl_branches,
             commands::gitlab::gl_mr_files,
             commands::gitlab::gl_mr_create_discussion,
diff --git a/apps/desktop/src-tauri/src/types.rs b/apps/desktop/src-tauri/src/types.rs
index 97868fd0..fa61aa83 100644
--- a/apps/desktop/src-tauri/src/types.rs
+++ b/apps/desktop/src-tauri/src/types.rs
@@ -411,6 +411,8 @@ pub struct GhPrDetailRaw {
     pub author: GhPrAuthor,
     #[serde(rename = "headRefName")]
     pub head_ref_name: String,
+    #[serde(rename = "headRefOid", default)]
+    pub head_ref_oid: String,
     #[serde(rename = "baseRefName")]
     pub base_ref_name: String,
     #[serde(rename = "isDraft")]
@@ -516,6 +518,10 @@ pub struct PullRequestDetail {
     /// disable the merge button on an unknown permission.
     #[serde(default)]
     pub can_merge: Option<bool>,
+    /// The PR/MR's current head commit SHA. Empty when a forge can't
+    /// cheaply provide one (callers must treat "" as "unknown", v3.6.0).
+    #[serde(default)]
+    pub head_sha: String,
 }
 
 // ─── Fork / PR target info ─────────────────────────────────────────
@@ -533,6 +539,16 @@ pub struct ForkInfo {
     pub parent: String,
 }
 
+/// GitLab MR diff refs (F1, v3.6.0) — the three SHAs needed to correctly
+/// position an inline discussion comment via the Discussions API.
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct MrDiffRefs {
+    pub base_sha: String,
+    pub start_sha: String,
+    pub head_sha: String,
+}
+
 // ─── GitHub OAuth device flow ──────────────────────────────────────
 
 /// Returned by `github_device_start` — the user-facing code + the
diff --git a/apps/desktop/src/App.vue b/apps/desktop/src/App.vue
index 6def1041..31a9785b 100644
--- a/apps/desktop/src/App.vue
+++ b/apps/desktop/src/App.vue
@@ -3278,7 +3278,8 @@ onUnmounted(() => {
               <PrCreateView v-if="prPanel.showCreateForm.value" class="view__content"
                 :current-branch="repoStatus?.branch ?? ''" :branches="branches" :cwd="repoFolderPath ?? ''" />
               <PrDetailView v-else class="view__content" @refresh="repoRefresh"
-                @navigate-commit="(hash) => { selectCommit(hash); viewMode = 'history'; }" />
+                @navigate-commit="(hash) => { selectCommit(hash); viewMode = 'history'; }"
+                @open-help="showHelp = true" />
               <div v-if="showPrRail" class="sidebar-handle" :class="{ 'sidebar-handle--active': sidebarResizing }"
                 @mousedown="onSidebarMouseDown"></div>
               <button class="commit-rail-toggle" :class="{ 'commit-rail-toggle--active': showPrRail }"
diff --git a/apps/desktop/src/components/HelpView.vue b/apps/desktop/src/components/HelpView.vue
index 66feec0a..3b0d5011 100644
--- a/apps/desktop/src/components/HelpView.vue
+++ b/apps/desktop/src/components/HelpView.vue
@@ -53,6 +53,18 @@ const shortcuts: { action: LocaleKey; keys: string[] }[] = [
   { action: "help.keyboardShortcuts.redoMerge",   keys: ["⌘⇧Z"] },
   { action: "help.keyboardShortcuts.saveAll",     keys: ["⌘S"] },
   { action: "help.keyboardShortcuts.closeOverlay", keys: ["Esc"] },
+  // PR Review — Diff tab only (B1, v3.6.0)
+  { action: "help.keyboardShortcuts.prNextHunk",   keys: ["J"] },
+  { action: "help.keyboardShortcuts.prPrevHunk",   keys: ["K"] },
+  { action: "help.keyboardShortcuts.prNextFile",   keys: ["⇧J"] },
+  { action: "help.keyboardShortcuts.prPrevFile",   keys: ["⇧K"] },
+  { action: "help.keyboardShortcuts.prToggleViewed", keys: ["V"] },
+  { action: "help.keyboardShortcuts.prHideViewed", keys: ["⇧V"] },
+  { action: "help.keyboardShortcuts.prFilterFiles", keys: ["T"] },
+  { action: "help.keyboardShortcuts.prCommentHunk", keys: ["C"] },
+  { action: "help.keyboardShortcuts.prNextFinding", keys: ["N"] },
+  { action: "help.keyboardShortcuts.prPrevFinding", keys: ["P"] },
+  { action: "help.keyboardShortcuts.prSubmitReview", keys: ["⌘↵"] },
 ];
 </script>
 
diff --git a/apps/desktop/src/components/PrCommentThread.vue b/apps/desktop/src/components/PrCommentThread.vue
index f6171f0e..3277cc71 100644
--- a/apps/desktop/src/components/PrCommentThread.vue
+++ b/apps/desktop/src/components/PrCommentThread.vue
@@ -30,8 +30,17 @@ const props = defineProps<{
   prNumber?: number;
   /** Forge name — routes reactions to the right backend. */
   forgeName?: string;
+  /** Whether the active forge supports editing a comment (F2) — hides the
+   *  affordance instead of calling into a forge that throws
+   *  `ForgeNotImplementedError` (e.g. Azure). Defaults to true. */
+  canEdit?: boolean;
+  /** Same contract as `canEdit`, for delete (F2). */
+  canDelete?: boolean;
 }>();
 
+const canEdit = computed(() => props.canEdit !== false);
+const canDelete = computed(() => props.canDelete !== false);
+
 const emit = defineEmits<{
   (e: "reply", body: string): void;
   (e: "delete", id: number): void;
@@ -127,14 +136,15 @@ function timeAgo(dateStr: string): string {
         <Avatar class="pct-avatar" :name="comment.author" :url="forgeAvatarUrl(forgeName, comment.author)" />
         <span class="pct-author">{{ comment.author }}</span>
         <span class="pct-time" :title="comment.created_at">{{ timeAgo(comment.created_at) }}</span>
-        <div class="pct-actions" v-if="comment.author === currentUser || !currentUser">
+        <div class="pct-actions" v-if="(canEdit || canDelete) && (comment.author === currentUser || !currentUser)">
           <button
-            v-if="editingId !== comment.id"
+            v-if="canEdit && editingId !== comment.id"
             class="pct-action-btn"
             @click="startEdit(comment)"
             :title="t('pr.comment.edit')"
           >✏️</button>
           <button
+            v-if="canDelete"
             class="pct-action-btn pct-action-btn--del"
             @click="emit('delete', comment.id)"
             :title="t('pr.comment.delete')"
diff --git a/apps/desktop/src/components/PrDetailView.vue b/apps/desktop/src/components/PrDetailView.vue
index acef50f5..098e23db 100644
--- a/apps/desktop/src/components/PrDetailView.vue
+++ b/apps/desktop/src/components/PrDetailView.vue
@@ -16,21 +16,27 @@ import { PR_PANEL_KEY, isMergeConflict, type PrPanelState } from "../composables
 import { renderMarkdown, onMarkdownLinkClick } from "../composables/useSafeHtml";
 import Avatar from "./Avatar.vue";
 import { forgeAvatarUrl } from "../composables/useAvatar";
-import { openExternalUrl } from "../utils/backend";
+import { openExternalUrl, type ReviewerCandidate } from "../utils/backend";
 import { useI18n } from "../composables/useI18n";
 import PrInlineDiff from "./PrInlineDiff.vue";
 import PrReviewModal from "./PrReviewModal.vue";
 import PrIntelligencePanel from "./PrIntelligencePanel.vue";
 import PrReactions from "./PrReactions.vue";
+import { resolvePrReviewShortcut, isEditableTarget } from "../composables/usePrReviewKeymap";
+import { usePrReviewNav } from "../composables/usePrReviewNav";
+import { useSettings } from "../composables/useSettings";
 
 const { t } = useI18n();
 
 const emit = defineEmits<{
   (e: "refresh"): void;
   (e: "navigate-commit", hash: string): void;
+  /** B1 `?` shortcut — the host (App.vue) owns the global HelpView toggle. */
+  (e: "open-help"): void;
 }>();
 
 const p = inject<PrPanelState>(PR_PANEL_KEY)!;
+const { settings } = useSettings();
 
 // window.open is a no-op in the Tauri webview — hand the URL to the OS opener.
 function openInBrowser(url: string) { void openExternalUrl(url); }
@@ -193,10 +199,32 @@ function trackMouse(e: MouseEvent) {
   lastMousePos.y = e.clientY;
 }
 
+const prInlineDiffRef = ref<InstanceType<typeof PrInlineDiff> | null>(null);
+const prReviewNav = usePrReviewNav({
+  prDiffFiles: p.prDiffFiles,
+  selectedDiffFile: p.selectedDiffFile,
+  selectedDiff: p.selectedDiff,
+  diffHandle: prInlineDiffRef,
+  onHelp: () => emit("open-help"),
+  onToggleViewed: (path) => p.toggleViewed(path),
+  hideViewed: p.hideViewed,
+  onSubmitReview: () => { p.showReviewModal.value = true; },
+  submittingReview: p.submittingReview,
+  findings: p.preReviewFindings,
+});
+
 function handleKeydown(e: KeyboardEvent) {
   if (e.key === "Escape" && fullscreenImageUrl.value) {
     fullscreenImageUrl.value = null;
   }
+  if (p.detailTab.value === "diff") {
+    const focused = !isEditableTarget(document.activeElement) && !fullscreenImageUrl.value;
+    const action = resolvePrReviewShortcut(e, { focused });
+    if (action) {
+      e.preventDefault();
+      prReviewNav.dispatch(action);
+    }
+  }
 }
 
 onMounted(() => {
@@ -246,6 +274,26 @@ async function scrollToLastComment() {
   commentsEnd.value?.scrollIntoView({ behavior: "smooth", block: "end" });
 }
 
+/** D1 — copy the AI PR summary to the clipboard. */
+function copySummary() {
+  if (p.prSummary.value) navigator.clipboard?.writeText(p.prSummary.value);
+}
+
+/** C4 — click a finding in the Intelligence panel's list: switch to the
+ *  Diff tab, select the file, and scroll to the finding's line. */
+async function jumpToFinding(path: string, line: number) {
+  p.detailTab.value = "diff";
+  p.selectedDiffFile.value = path;
+  await nextTick();
+  const rows = prInlineDiffRef.value?.rows ?? [];
+  const rowIdx = rows.findIndex((r: any) => {
+    if (r.kind !== "line") return false;
+    const lineNo = r.dl.type === "delete" ? r.dl.oldLineNo : r.dl.newLineNo;
+    return lineNo === line;
+  });
+  if (rowIdx !== -1) prInlineDiffRef.value?.scrollToLine(rowIdx);
+}
+
 /**
  * Web URL for a comment's "Go to" button. GitHub/Bitbucket expose a direct
  * per-comment permalink; GitLab/Azure don't, so fall back to the PR/MR page
@@ -268,6 +316,27 @@ function commentTimeAgo(dateStr: string): string {
     return `${Math.floor(hours / 24)}j`;
   } catch { return dateStr; }
 }
+
+// ─── Reviews admin: dismiss + request reviewers (B4) ───────
+const reviewerCandidates = ref<ReviewerCandidate[]>([]);
+const requestReviewersInput = ref("");
+
+async function loadReviewerCandidatesOnce() {
+  if (!p.forgeSupportsRequestReviewers.value || reviewerCandidates.value.length || !p.cwd.value) return;
+  try {
+    reviewerCandidates.value = await p.forge.value.listReviewerCandidates(p.cwd.value);
+  } catch { /* non-fatal — the input still works without suggestions */ }
+}
+
+function submitRequestReviewers() {
+  const logins = requestReviewersInput.value
+    .split(/[,\s]+/)
+    .map((s) => s.replace(/^@/, "").trim())
+    .filter(Boolean);
+  if (!logins.length) return;
+  p.handleRequestReviewers(logins);
+  requestReviewersInput.value = "";
+}
 </script>
 
 <template>
@@ -557,6 +626,37 @@ function commentTimeAgo(dateStr: string): string {
             <span class="pdv-readiness-text">{{ p.mergeReadiness.value.reason }}</span>
           </div>
 
+          <!-- AI PR summary (D1, v3.6.0) — opt-in, shown only once something
+               has actually loaded/is loading, never an empty shell. -->
+          <section
+            v-if="settings.reviewAiSummary && (p.prSummary.value || p.prSummaryLoading.value)"
+            class="pdv-summary"
+          >
+            <header class="pdv-summary-head">
+              <h2 class="pdv-section-label">{{ t('pr.summary.title') }}</h2>
+              <div class="pdv-summary-actions">
+                <button
+                  type="button"
+                  class="pdv-summary-btn"
+                  :disabled="p.prSummaryLoading.value"
+                  :title="t('pr.summary.regenerate')"
+                  @click="p.regenerateSummary()"
+                >{{ t('pr.summary.regenerate') }}</button>
+                <button
+                  type="button"
+                  class="pdv-summary-btn"
+                  :disabled="!p.prSummary.value"
+                  :title="t('pr.summary.copy')"
+                  @click="copySummary"
+                >{{ t('pr.summary.copy') }}</button>
+              </div>
+            </header>
+            <div v-if="p.prSummaryLoading.value && !p.prSummary.value" class="pdv-summary-loading">
+              {{ t('pr.summary.loading') }}
+            </div>
+            <div v-else class="pdv-summary-body" v-html="renderMarkdown(p.prSummary.value)" />
+          </section>
+
           <!-- Stat cards -->
           <div class="pdv-stats-grid">
             <div class="pdv-stat">
@@ -616,14 +716,32 @@ function commentTimeAgo(dateStr: string): string {
           </div>
 
           <!-- Reviewers -->
-          <section v-if="p.prDetail.value.reviewers.length" class="pdv-section">
+          <section v-if="p.prDetail.value.reviewers.length || p.forgeSupportsRequestReviewers.value" class="pdv-section">
             <h2 class="pdv-section-label">{{ t('pr.detail.reviewers') }}</h2>
-            <div class="pdv-chips">
+            <div v-if="p.prDetail.value.reviewers.length" class="pdv-chips">
               <span v-for="r in p.prDetail.value.reviewers" :key="r" class="pdv-chip pdv-chip--reviewer">
                 <Avatar class="pdv-chip-avatar" :name="r" :url="forgeAvatarUrl(p.forge.value.name, r)" />
                 {{ r }}
               </span>
             </div>
+            <!-- B4 — request reviewers (capability-gated: hidden, not erroring, when unsupported) -->
+            <div v-if="p.forgeSupportsRequestReviewers.value" class="pdv-request-reviewers">
+              <input
+                v-model="requestReviewersInput"
+                type="text"
+                list="pdv-reviewer-suggestions"
+                class="pdv-request-reviewers-input"
+                :placeholder="t('pr.reviews.requestReviewersPlaceholder')"
+                @focus="loadReviewerCandidatesOnce"
+                @keydown.enter.prevent="submitRequestReviewers"
+              />
+              <datalist id="pdv-reviewer-suggestions">
+                <option v-for="c in reviewerCandidates" :key="c.login" :value="c.login" />
+              </datalist>
+              <button type="button" class="pdv-request-reviewers-btn" @click="submitRequestReviewers">
+                {{ t('pr.reviews.requestReviewers') }}
+              </button>
+            </div>
           </section>
 
           <!-- Labels -->
@@ -715,6 +833,14 @@ function commentTimeAgo(dateStr: string): string {
                       </svg>
                     </button>
                     <span class="pdv-comment-time" :title="item.ts">{{ commentTimeAgo(item.ts) }}</span>
+                    <!-- B4 — dismiss (capability-gated; hidden rather than erroring on GitLab/Bitbucket/Azure) -->
+                    <button
+                      v-if="p.forgeSupportsDismissReview.value && item.verdictCls !== 'pdv-review--dismissed' && item.id"
+                      type="button"
+                      class="pdv-review-dismiss"
+                      :title="t('pr.reviews.dismiss')"
+                      @click="p.handleDismissReview(item.id)"
+                    >{{ t('pr.reviews.dismiss') }}</button>
                   </div>
                   <div v-if="item.bodyHtml" class="pdv-comment-body" @click="onMarkdownLinkClick" v-html="item.bodyHtml" />
                   <!-- Reactions only on reviews that carry a body — there is no
@@ -777,13 +903,34 @@ function commentTimeAgo(dateStr: string): string {
             <!-- File sidebar -->
             <div class="pdv-diff-sidebar">
               <div class="pdv-diff-count">{{ t('pr.detail.filesCount', p.prDiffFiles.value.length) }}</div>
+              <!-- B2 — viewed-file progress + hide-viewed toggle -->
+              <div class="pdv-diff-viewed-bar">
+                <span class="pdv-diff-viewed-progress">
+                  {{ t('pr.viewed.progress', p.viewedCount.value, p.prDiffFiles.value.length) }}
+                </span>
+                <button
+                  type="button"
+                  class="pdv-diff-viewed-hide"
+                  :class="{ 'pdv-diff-viewed-hide--active': p.hideViewed.value }"
+                  :aria-pressed="p.hideViewed.value"
+                  :title="t('pr.viewed.hide')"
+                  @click="p.hideViewed.value = !p.hideViewed.value"
+                >{{ t('pr.viewed.hide') }}</button>
+              </div>
               <button
-                v-for="file in p.prDiffFiles.value"
+                v-for="file in p.visibleDiffFiles.value"
                 :key="file.path"
                 :class="['pdv-diff-file', { 'pdv-diff-file--active': p.selectedDiffFile.value === file.path }]"
                 @click="p.selectedDiffFile.value = file.path"
               >
                 <div class="pdv-diff-file-top">
+                  <input
+                    type="checkbox"
+                    class="pdv-diff-file-viewed"
+                    :checked="p.viewedPaths.value.has(file.path)"
+                    :title="t('pr.viewed.toggle')"
+                    @click.stop="p.toggleViewed(file.path)"
+                  />
                   <span class="pdv-diff-file-name">{{ file.path.split('/').pop() }}</span>
                   <!-- v2.18 — CI annotations on this file -->
                   <span
@@ -803,6 +950,7 @@ function commentTimeAgo(dateStr: string): string {
             <div class="pdv-diff-viewer">
               <PrInlineDiff
                 v-if="p.selectedDiff.value"
+                ref="prInlineDiffRef"
                 :diff="p.selectedDiff.value"
                 :file-path="p.selectedDiffFile.value"
                 :comments="p.commentsForFile.value"
@@ -811,7 +959,9 @@ function commentTimeAgo(dateStr: string): string {
                 :cwd="p.cwd.value"
                 :pr-number="p.selectedPr.value?.number"
                 :forge-name="p.forge.value.name"
-                :annotations="p.selectedDiffFile.value ? (p.annotationsByFile.value[p.selectedDiffFile.value] ?? []) : []"
+                :annotations="p.selectedDiffFile.value ? (p.mergedAnnotationsByFile.value[p.selectedDiffFile.value] ?? []) : []"
+                :can-edit-comments="p.forgeSupportsCommentEdit.value"
+                :can-delete-comments="p.forgeSupportsCommentDelete.value"
                 @create-comment="p.handleCreateComment"
                 @add-to-review="p.handleAddToReview"
                 @reply-comment="p.handleReplyComment"
@@ -860,9 +1010,15 @@ function commentTimeAgo(dateStr: string): string {
             :hotspots-loading="p.hotspotsLoading.value"
             :file-history="p.fileHistory.value"
             :file-history-loading="p.fileHistoryLoading.value"
+            :pre-review-findings="p.preReviewFindings.value"
+            :pre-review-progress="p.preReviewProgress.value"
+            :pre-review-running="p.preReviewRunning.value"
+            :static-flags="p.staticFlags.value"
             @load-conflict-preview="p.loadConflictPreview"
             @load-hotspots="p.loadHotspots"
             @load-file-history="p.loadFileHistory"
+            @dismiss-finding="p.dismissFinding"
+            @jump-to-finding="jumpToFinding"
           />
         </div>
       </div>
@@ -1382,6 +1538,52 @@ function commentTimeAgo(dateStr: string): string {
   font-weight: var(--font-weight-semibold);
 }
 
+/* AI PR summary (D1, v3.6.0) */
+.pdv-summary {
+  padding: var(--space-4) var(--space-5);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  background: var(--color-bg-secondary);
+}
+.pdv-summary-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--space-3);
+  margin-bottom: var(--space-2);
+}
+.pdv-summary-actions {
+  display: flex;
+  gap: var(--space-2);
+  flex-shrink: 0;
+}
+.pdv-summary-btn {
+  font-size: var(--font-size-xs);
+  padding: 2px var(--space-2);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--color-text-muted);
+  cursor: pointer;
+}
+.pdv-summary-btn:hover:not(:disabled) {
+  color: var(--color-accent);
+  border-color: var(--color-accent);
+}
+.pdv-summary-btn:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+.pdv-summary-loading {
+  font-size: var(--font-size-sm);
+  color: var(--color-text-muted);
+}
+.pdv-summary-body {
+  font-size: var(--font-size-sm);
+  line-height: var(--line-height-relaxed, 1.6);
+  color: var(--color-text);
+}
+
 /* Stats grid */
 .pdv-stats-grid {
   display: grid;
@@ -1613,6 +1815,52 @@ function commentTimeAgo(dateStr: string): string {
   border-color: var(--color-accent);
 }
 
+/* B4 — dismiss review */
+.pdv-review-dismiss {
+  padding: 1px var(--space-2);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--color-text-muted);
+  font-size: var(--font-size-xs);
+  cursor: pointer;
+}
+.pdv-review-dismiss:hover {
+  color: var(--color-danger, #ef4444);
+  border-color: var(--color-danger, #ef4444);
+}
+
+/* B4 — request reviewers */
+.pdv-request-reviewers {
+  display: flex;
+  gap: var(--space-2);
+  margin-top: var(--space-2);
+}
+.pdv-request-reviewers-input {
+  flex: 1;
+  min-width: 0;
+  padding: var(--space-2) var(--space-3);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: var(--color-bg);
+  color: var(--color-text);
+  font-size: var(--font-size-sm);
+}
+.pdv-request-reviewers-btn {
+  padding: var(--space-2) var(--space-3);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--color-text);
+  font-size: var(--font-size-sm);
+  cursor: pointer;
+  white-space: nowrap;
+}
+.pdv-request-reviewers-btn:hover {
+  border-color: var(--color-accent);
+  color: var(--color-accent);
+}
+
 .pdv-comment-body {
   color: var(--color-text);
   font-size: var(--font-size-sm);
@@ -2015,6 +2263,37 @@ function commentTimeAgo(dateStr: string): string {
   padding: var(--space-2) var(--space-3) var(--space-4);
 }
 
+/* B2 — viewed-file progress bar + hide-viewed toggle */
+.pdv-diff-viewed-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--space-2);
+  padding: 0 var(--space-3) var(--space-3);
+  margin-top: calc(var(--space-4) * -1);
+}
+.pdv-diff-viewed-progress {
+  font-size: var(--font-size-xs);
+  color: var(--color-text-muted);
+}
+.pdv-diff-viewed-hide {
+  font-size: var(--font-size-xs);
+  color: var(--color-text-muted);
+  background: transparent;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  padding: 2px 8px;
+  cursor: pointer;
+}
+.pdv-diff-viewed-hide--active {
+  color: var(--color-accent);
+  border-color: var(--color-accent);
+}
+.pdv-diff-file-viewed {
+  flex-shrink: 0;
+  cursor: pointer;
+}
+
 .pdv-diff-file {
   display: flex;
   flex-direction: column;
diff --git a/apps/desktop/src/components/PrInlineDiff.vue b/apps/desktop/src/components/PrInlineDiff.vue
index 67145c01..4643b56c 100644
--- a/apps/desktop/src/components/PrInlineDiff.vue
+++ b/apps/desktop/src/components/PrInlineDiff.vue
@@ -10,7 +10,8 @@
  *  - Code suggestion apply support
  */
 import { ref, computed } from "vue";
-import type { GitDiff, DiffLine, PrReviewComment, CIAnnotation } from "../utils/backend";
+import type { GitDiff, DiffLine, PrReviewComment } from "../utils/backend";
+import { annotationsByLine as groupAnnotationsByLine, worstSeverity, type LineAnnotation } from "../composables/prAnnotations";
 import PrCommentThread from "./PrCommentThread.vue";
 import AiSparkle from "./AiSparkle.vue";
 import { detectLanguage, highlightLine } from "../utils/highlight";
@@ -18,6 +19,7 @@ import { safeHtml } from "../composables/useSafeHtml";
 import { useAIProvider } from "../composables/useAIProvider";
 import { usePrHunkCritique, type HunkCritiqueResult } from "../composables/usePrHunkCritique";
 import { useI18n } from "../composables/useI18n";
+import { useVirtualRows } from "../composables/useVirtualRows";
 
 const props = defineProps<{
   diff: GitDiff | null;
@@ -31,8 +33,12 @@ const props = defineProps<{
   cwd?: string;
   prNumber?: number;
   forgeName?: string;
-  /** CI check-run annotations for this file (v2.18). */
-  annotations?: CIAnnotation[];
+  /** Merged CI + AI + static-flag annotations for this file (E1, v3.6.0). */
+  annotations?: LineAnnotation[];
+  /** Whether the active forge supports editing a comment (F2). Defaults to true. */
+  canEditComments?: boolean;
+  /** Whether the active forge supports deleting a comment (F2). Defaults to true. */
+  canDeleteComments?: boolean;
 }>();
 
 interface CommentParams {
@@ -158,40 +164,39 @@ function threadsForLine(line: DiffLine): Thread[] {
   });
 }
 
-// ─── CI annotations (v2.18) ──────────────────────────────
-// Annotations are anchored on the head commit → matched on `newLineNo`.
-// Ranges are expanded line-by-line, capped so a report spanning a whole
-// file doesn't flag hundreds of rows.
-const ANN_RANGE_CAP = 20;
-const ANN_ICONS: Record<CIAnnotation["level"], string> = {
+// ─── Line annotations (E1, v3.6.0 — CI + AI + static, unified) ──────────
+// CI annotations were previously matched new-side-only (`newLineNo`), since
+// GitHub/GitLab/Bitbucket check-runs are always anchored on the head commit.
+// The shared model supports both sides (LEFT for AI/static findings on
+// removed lines); CI-only behavior stays byte-identical (still RIGHT-only)
+// since `fromCIAnnotation` always sets `side: "RIGHT"`.
+const ANN_ICONS: Record<string, string> = {
   failure: "❌",
+  risk: "❌",
   warning: "⚠",
+  suggestion: "⚠",
   notice: "ℹ",
+  nit: "ℹ",
 };
 
-const annotationsByLine = computed<Map<number, CIAnnotation[]>>(() => {
-  const map = new Map<number, CIAnnotation[]>();
-  for (const a of props.annotations ?? []) {
-    const end = Math.min(a.endLine, a.startLine + ANN_RANGE_CAP - 1);
-    for (let l = a.startLine; l <= end; l++) {
-      const list = map.get(l);
-      if (list) list.push(a);
-      else map.set(l, [a]);
-    }
-  }
-  return map;
-});
+const mergedAnnotationsByLine = computed(() => groupAnnotationsByLine(props.annotations ?? []));
 
-function annotationsForLine(line: DiffLine): CIAnnotation[] {
-  if (line.newLineNo == null) return [];
-  return annotationsByLine.value.get(line.newLineNo) ?? [];
+function annotationsForLine(line: DiffLine): LineAnnotation[] {
+  const anns: LineAnnotation[] = [];
+  if (line.newLineNo != null) {
+    anns.push(...(mergedAnnotationsByLine.value.get(`RIGHT:${line.newLineNo}`) ?? []));
+  }
+  // Delete lines have no RIGHT side — this is purely additive (previously
+  // always matched nothing here, since CI annotations are RIGHT-only).
+  if (line.oldLineNo != null && line.type === "delete") {
+    anns.push(...(mergedAnnotationsByLine.value.get(`LEFT:${line.oldLineNo}`) ?? []));
+  }
+  return anns;
 }
 
-/** Worst level wins for the gutter icon: failure > warning > notice. */
-function annotationLevel(anns: CIAnnotation[]): CIAnnotation["level"] {
-  if (anns.some((a) => a.level === "failure")) return "failure";
-  if (anns.some((a) => a.level === "warning")) return "warning";
-  return "notice";
+/** Worst severity wins for the gutter icon. */
+function annotationLevel(anns: LineAnnotation[]): string {
+  return worstSeverity(anns);
 }
 
 // ─── Compose new comment ─────────────────────────────────
@@ -324,6 +329,145 @@ function handleDelete(id: number) {
 function handleApplySuggestion(suggestion: string, startLine: number | null, endLine: number | null) {
   emit("apply-suggestion", suggestion, startLine, endLine);
 }
+
+// ─── Flat row model (A2) ──────────────────────────────────
+// Threads, the critique panel, and the compose/suggest boxes are normally
+// injected *between* hunk/line rows by the template above. Virtualization
+// needs every one of them to be an addressable row so the virtualizer can
+// measure and position it — so the diff is also expressed as a flat
+// `rows: DiffRow[]` list, in the exact order the full-DOM template renders.
+export type DiffRow =
+  | { kind: "hunk-header"; hunkIdx: number }
+  | { kind: "critique"; hunkIdx: number }
+  | { kind: "line"; hunkIdx: number; lineIdx: number; dl: DiffLine }
+  | { kind: "thread"; hunkIdx: number; lineIdx: number; dl: DiffLine; thread: Thread }
+  | { kind: "compose"; hunkIdx: number; lineIdx: number; dl: DiffLine }
+  | { kind: "suggest"; hunkIdx: number; lineIdx: number; dl: DiffLine };
+
+function critiquePanelVisible(hunkIdx: number): boolean {
+  return (
+    critiqueOpenIdx.value === hunkIdx &&
+    !!(critiqueResults.value[hunkIdx] || critiqueLoadingIdx.value === hunkIdx || critiqueAiError.value)
+  );
+}
+
+const rows = computed<DiffRow[]>(() => {
+  const out: DiffRow[] = [];
+  if (!props.diff) return out;
+  props.diff.hunks.forEach((hunk, hunkIdx) => {
+    out.push({ kind: "hunk-header", hunkIdx });
+    if (critiquePanelVisible(hunkIdx)) out.push({ kind: "critique", hunkIdx });
+    hunk.lines.forEach((dl, lineIdx) => {
+      out.push({ kind: "line", hunkIdx, lineIdx, dl });
+      for (const thread of threadsForLine(dl)) {
+        out.push({ kind: "thread", hunkIdx, lineIdx, dl, thread });
+      }
+      if (isComposeAnchoredAt(dl)) out.push({ kind: "compose", hunkIdx, lineIdx, dl });
+      if (isSuggestAnchoredAt(dl)) out.push({ kind: "suggest", hunkIdx, lineIdx, dl });
+    });
+  });
+  return out;
+});
+
+/** True for the first row belonging to a given hunk (drives the "boxed hunk"
+ *  top border/corner once the per-hunk wrapper div is gone, see A2 CSS). */
+function isHunkStart(idx: number): boolean {
+  const row = rows.value[idx];
+  return idx === 0 || rows.value[idx - 1]?.hunkIdx !== row.hunkIdx;
+}
+
+/** True for the last row belonging to a given hunk. */
+function isHunkEnd(idx: number): boolean {
+  const row = rows.value[idx];
+  return idx === rows.value.length - 1 || rows.value[idx + 1]?.hunkIdx !== row.hunkIdx;
+}
+
+function rowKey(row: DiffRow, idx: number): string {
+  if (row.kind === "hunk-header" || row.kind === "critique") return `${row.kind}:${row.hunkIdx}`;
+  if (row.kind === "thread") return `thread:${row.thread.key}:${idx}`;
+  return `${row.kind}:${row.hunkIdx}:${row.lineIdx}`;
+}
+
+// ─── Virtualization (A2) ───────────────────────────────────
+// Full DOM under the threshold (native find/select stay intact); virtualized
+// above it so a huge single-hunk file doesn't render thousands of live rows.
+const ROW_VIRTUALIZE_THRESHOLD = 300;
+const isVirtual = computed(() => rows.value.length >= ROW_VIRTUALIZE_THRESHOLD);
+const scrollContainerRef = ref<HTMLElement | null>(null);
+
+const ROW_ESTIMATE_SIZE: Record<DiffRow["kind"], number> = {
+  "hunk-header": 24,
+  critique: 60,
+  line: 20,
+  thread: 110,
+  compose: 160,
+  suggest: 180,
+};
+
+const { virtualizer, virtualItems, totalSize, measure } = useVirtualRows({
+  count: computed(() => rows.value.length),
+  getScrollElement: () => scrollContainerRef.value,
+  estimateSize: (index: number) => ROW_ESTIMATE_SIZE[rows.value[index]?.kind ?? "line"],
+  overscan: 20,
+});
+
+/** Pairs each virtual item with its already-discriminated `DiffRow` — lets
+ *  the virtualized template branch on `row.kind` with the same type
+ *  narrowing the non-virtual `v-for="(row, idx) in rows"` branch gets
+ *  (indexing `rows[vr.index]` fresh on every reference does not narrow). */
+const virtualRowsView = computed(() =>
+  virtualItems.value.map((vr) => ({ vr, row: rows.value[vr.index] })),
+);
+
+function vrStyle(vr: { start: number; size: number }) {
+  return {
+    position: "absolute" as const,
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: vr.size + "px",
+    overflow: "visible" as const,
+    transform: "translateY(" + vr.start + "px)",
+  };
+}
+
+/** Keyboard-nav cursor (B1) — index into `rows`. Kept here (not in the host)
+ *  so `scrollToHunk`/`scrollToLine` can highlight/scroll in one call. */
+const currentRowIdx = ref(0);
+
+function scrollRowIntoView(idx: number) {
+  if (isVirtual.value) {
+    virtualizer.value?.scrollToIndex(idx, { align: "auto" });
+    return;
+  }
+  const el = (scrollContainerRef.value ?? document).querySelector?.(`[data-row-index="${idx}"]`);
+  el?.scrollIntoView?.({ block: "nearest" });
+}
+
+/** Scroll to (and select) the first row of hunk `hunkIdx`. */
+function scrollToHunk(hunkIdx: number) {
+  const idx = rows.value.findIndex((r) => r.kind === "hunk-header" && r.hunkIdx === hunkIdx);
+  if (idx === -1) return;
+  currentRowIdx.value = idx;
+  scrollRowIntoView(idx);
+}
+
+/** Scroll to (and select) an arbitrary row by its index in `rows`. */
+function scrollToLine(rowIdx: number) {
+  if (rowIdx < 0 || rowIdx >= rows.value.length) return;
+  currentRowIdx.value = rowIdx;
+  scrollRowIntoView(rowIdx);
+}
+
+/** B1 `C` shortcut — open the compose box anchored at the first line of the
+ *  given hunk (the "current hunk" the keyboard cursor is on). */
+function openComposeAtHunk(hunkIdx: number) {
+  const hunk = props.diff?.hunks[hunkIdx];
+  if (!hunk || !hunk.lines.length) return;
+  openCompose(hunkIdx, 0, hunk.lines[0]);
+}
+
+defineExpose({ scrollToHunk, scrollToLine, openComposeAtHunk, rows, currentRowIdx });
 </script>
 
 <template>
@@ -331,24 +475,27 @@ function handleApplySuggestion(suggestion: string, startLine: number | null, end
     <div v-if="!diff || !diff.hunks.length" class="pid-empty">
       Aucun diff disponible.
     </div>
-    <template v-else>
-      <div
-        v-for="(hunk, hunkIdx) in diff.hunks"
-        :key="hunkIdx"
-        class="pid-hunk"
-      >
+    <!-- A2: full DOM under the virtualization threshold — keeps native
+         Cmd+F / text-select working, identical markup to the virtual path. -->
+    <div v-else-if="!isVirtual" class="pid-rows">
+      <template v-for="(row, idx) in rows" :key="rowKey(row, idx)">
         <!-- Hunk header -->
-        <div class="pid-hunk-header mono">
-          <span class="pid-hunk-header-text">{{ hunk.header }}</span>
+        <div
+          v-if="row.kind === 'hunk-header'"
+          class="pid-hunk-header mono pid-rowbox pid-rowbox--start"
+          :class="{ 'pid-rowbox--end': isHunkEnd(idx) }"
+          :data-row-index="idx"
+        >
+          <span class="pid-hunk-header-text">{{ diff.hunks[row.hunkIdx].header }}</span>
           <button
             v-if="ai.isAvailable.value"
             class="btn btn--ai pid-hunk-ai"
-            :class="{ 'pid-hunk-ai--active': critiqueOpenIdx === hunkIdx }"
-            :disabled="critiqueLoadingIdx === hunkIdx"
+            :class="{ 'pid-hunk-ai--active': critiqueOpenIdx === row.hunkIdx }"
+            :disabled="critiqueLoadingIdx === row.hunkIdx"
             :title="t('prInline.aiCritiqueTooltip')"
-            @click="requestHunkCritique(hunkIdx)"
+            @click="requestHunkCritique(row.hunkIdx)"
           >
-            <span v-if="critiqueLoadingIdx === hunkIdx">…</span>
+            <span v-if="critiqueLoadingIdx === row.hunkIdx">…</span>
             <span v-else class="pid-ai-label">
               <AiSparkle :size="13" />
               {{ t('prInline.aiCritiqueButton') }}
@@ -358,210 +505,447 @@ function handleApplySuggestion(suggestion: string, startLine: number | null, end
 
         <!-- AI critique panel -->
         <div
-          v-if="critiqueOpenIdx === hunkIdx && (critiqueResults[hunkIdx] || critiqueLoadingIdx === hunkIdx || critiqueAiError)"
-          class="pid-critique"
-          :class="critiqueResults[hunkIdx] ? verdictClass(critiqueResults[hunkIdx]!.verdict) : ''"
+          v-else-if="row.kind === 'critique'"
+          class="pid-critique pid-rowbox"
+          :class="[critiqueResults[row.hunkIdx] ? verdictClass(critiqueResults[row.hunkIdx]!.verdict) : '', { 'pid-rowbox--end': isHunkEnd(idx) }]"
           role="status"
           aria-live="polite"
+          :data-row-index="idx"
         >
           <span class="pid-critique-icon">
-            <template v-if="critiqueResults[hunkIdx]">{{ verdictIcon(critiqueResults[hunkIdx]!.verdict) }}</template>
+            <template v-if="critiqueResults[row.hunkIdx]">{{ verdictIcon(critiqueResults[row.hunkIdx]!.verdict) }}</template>
             <AiSparkle v-else :size="14" />
           </span>
           <span class="pid-critique-body">
-            <span v-if="critiqueAiError && !critiqueResults[hunkIdx]" class="pid-critique-error">{{ critiqueAiError }}</span>
-            <span v-else-if="critiqueLoadingIdx === hunkIdx && !critiqueResults[hunkIdx]">
+            <span v-if="critiqueAiError && !critiqueResults[row.hunkIdx]" class="pid-critique-error">{{ critiqueAiError }}</span>
+            <span v-else-if="critiqueLoadingIdx === row.hunkIdx && !critiqueResults[row.hunkIdx]">
               {{ t('prInline.aiCritiqueAnalyzing') }}
             </span>
-            <template v-else-if="critiqueResults[hunkIdx]">
-              <span class="pid-critique-verdict">{{ critiqueResults[hunkIdx]!.verdict }}</span>
-              <span class="pid-critique-summary">{{ critiqueResults[hunkIdx]!.summary }}</span>
+            <template v-else-if="critiqueResults[row.hunkIdx]">
+              <span class="pid-critique-verdict">{{ critiqueResults[row.hunkIdx]!.verdict }}</span>
+              <span class="pid-critique-summary">{{ critiqueResults[row.hunkIdx]!.summary }}</span>
             </template>
           </span>
           <button
-            v-if="critiqueLoadingIdx !== hunkIdx"
+            v-if="critiqueLoadingIdx !== row.hunkIdx"
             class="pid-critique-close"
             @click="dismissCritique"
             aria-label="Close"
           >✕</button>
         </div>
 
-        <!-- Lines -->
-        <template v-for="(dl, lineIdx) in hunk.lines" :key="lineIdx">
-          <!-- Diff row -->
-          <div
-            class="pid-row"
-            :class="{
-              'pid-row--add': dl.type === 'add',
-              'pid-row--del': dl.type === 'delete',
-              'pid-row--ctx': dl.type === 'context',
-              'pid-row--annotated': annotationsForLine(dl).length > 0,
-            }"
-          >
-            <!-- CI annotation gutter icon + hover tooltip (v2.18) -->
-            <div v-if="annotationsForLine(dl).length" class="pid-ann">
-              <span
-                class="pid-ann-icon"
-                :class="`pid-ann-icon--${annotationLevel(annotationsForLine(dl))}`"
-              >{{ ANN_ICONS[annotationLevel(annotationsForLine(dl))] }}</span>
-              <div class="pid-ann-tip">
-                <div
-                  v-for="(a, ai) in annotationsForLine(dl)"
-                  :key="ai"
-                  class="pid-ann-tip-item"
-                >
-                  <div class="pid-ann-tip-head">
-                    <span>{{ ANN_ICONS[a.level] }}</span>
-                    <span class="pid-ann-tip-title">{{ a.title || a.checkName }}</span>
-                  </div>
-                  <div v-if="a.message" class="pid-ann-tip-msg">{{ a.message }}</div>
-                  <div class="pid-ann-tip-src">{{ a.checkName }}</div>
+        <!-- Diff line -->
+        <div
+          v-else-if="row.kind === 'line'"
+          class="pid-row pid-rowbox"
+          :class="{
+            'pid-row--add': row.dl.type === 'add',
+            'pid-row--del': row.dl.type === 'delete',
+            'pid-row--ctx': row.dl.type === 'context',
+            'pid-row--annotated': annotationsForLine(row.dl).length > 0,
+            'pid-rowbox--start': isHunkStart(idx),
+            'pid-rowbox--end': isHunkEnd(idx),
+          }"
+          :data-row-index="idx"
+        >
+          <!-- CI annotation gutter icon + hover tooltip (v2.18) -->
+          <div v-if="annotationsForLine(row.dl).length" class="pid-ann">
+            <span
+              class="pid-ann-icon"
+              :class="`pid-ann-icon--${annotationLevel(annotationsForLine(row.dl))}`"
+            >{{ ANN_ICONS[annotationLevel(annotationsForLine(row.dl))] }}</span>
+            <div class="pid-ann-tip">
+              <div
+                v-for="(a, ai) in annotationsForLine(row.dl)"
+                :key="ai"
+                class="pid-ann-tip-item"
+              >
+                <div class="pid-ann-tip-head">
+                  <span>{{ ANN_ICONS[a.severity] }}</span>
+                  <span class="pid-ann-tip-title">{{ a.title || a.checkName }}</span>
+                  <span v-if="a.confidence != null" class="pid-ann-tip-confidence">{{ a.confidence }}%</span>
                 </div>
+                <div v-if="a.message" class="pid-ann-tip-msg">{{ a.message }}</div>
+                <div class="pid-ann-tip-src">{{ a.checkName || a.source }}</div>
               </div>
             </div>
-            <!-- Old line number -->
-            <div
-              class="pid-lno mono"
-              :class="{ 'pid-lno--clickable': dl.type !== 'add' }"
-              @click="dl.type !== 'add' && openCompose(hunkIdx, lineIdx, dl)"
-              :title="dl.type !== 'add' ? 'Ajouter un commentaire' : undefined"
-            >
-              <span class="pid-lno-num">{{ dl.oldLineNo ?? '' }}</span>
-              <span class="pid-lno-icon">+</span>
-            </div>
-            <!-- New line number -->
-            <div
-              class="pid-lno mono"
-              :class="{ 'pid-lno--clickable': dl.type !== 'delete' }"
-              @click="dl.type !== 'delete' && openCompose(hunkIdx, lineIdx, dl)"
-              :title="dl.type !== 'delete' ? 'Ajouter un commentaire' : undefined"
-            >
-              <span class="pid-lno-num">{{ dl.newLineNo ?? '' }}</span>
-              <span class="pid-lno-icon">+</span>
-            </div>
-            <!-- Marker -->
-            <div class="pid-marker mono">
-              {{ dl.type === 'add' ? '+' : dl.type === 'delete' ? '-' : ' ' }}
-            </div>
-            <!-- Content -->
-            <div class="pid-content mono" v-html="safeHtml(hl(dl.content)) || '&nbsp;'" />
-            <!-- Suggest button (v2.13) — visible on hover for add/context lines -->
-            <button
-              v-if="dl.type !== 'delete'"
-              class="pid-suggest-btn"
-              :title="t('pr.inline.suggestTooltip')"
-              @click.stop="openSuggest(hunkIdx, lineIdx, dl)"
-            >
-              <svg width="12" height="12" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4">
-                <path d="M11 2.5l2.5 2.5L5 13.5H2.5V11L11 2.5z" stroke-linejoin="round"/>
-              </svg>
-            </button>
           </div>
-
-          <!-- Comment threads anchored to this line -->
+          <!-- Old line number -->
           <div
-            v-for="thread in threadsForLine(dl)"
-            :key="thread.key"
-            class="pid-thread-row"
+            class="pid-lno mono"
+            :class="{ 'pid-lno--clickable': row.dl.type !== 'add' }"
+            @click="row.dl.type !== 'add' && openCompose(row.hunkIdx, row.lineIdx, row.dl)"
+            :title="row.dl.type !== 'add' ? 'Ajouter un commentaire' : undefined"
           >
-            <div class="pid-thread-gutter" />
-            <div class="pid-thread-body">
-              <PrCommentThread
-                :comments="thread.comments"
-                :current-user="currentUser"
-                :cwd="cwd"
-                :pr-number="prNumber"
-                :forge-name="forgeName"
-                @reply="(body) => handleReply(thread, body)"
-                @edit="handleEdit"
-                @delete="handleDelete"
-                @apply-suggestion="handleApplySuggestion"
+            <span class="pid-lno-num">{{ row.dl.oldLineNo ?? '' }}</span>
+            <span class="pid-lno-icon">+</span>
+          </div>
+          <!-- New line number -->
+          <div
+            class="pid-lno mono"
+            :class="{ 'pid-lno--clickable': row.dl.type !== 'delete' }"
+            @click="row.dl.type !== 'delete' && openCompose(row.hunkIdx, row.lineIdx, row.dl)"
+            :title="row.dl.type !== 'delete' ? 'Ajouter un commentaire' : undefined"
+          >
+            <span class="pid-lno-num">{{ row.dl.newLineNo ?? '' }}</span>
+            <span class="pid-lno-icon">+</span>
+          </div>
+          <!-- Marker -->
+          <div class="pid-marker mono">
+            {{ row.dl.type === 'add' ? '+' : row.dl.type === 'delete' ? '-' : ' ' }}
+          </div>
+          <!-- Content -->
+          <div class="pid-content mono" v-html="safeHtml(hl(row.dl.content)) || '&nbsp;'" />
+          <!-- Suggest button (v2.13) — visible on hover for add/context lines -->
+          <button
+            v-if="row.dl.type !== 'delete'"
+            class="pid-suggest-btn"
+            :title="t('pr.inline.suggestTooltip')"
+            @click.stop="openSuggest(row.hunkIdx, row.lineIdx, row.dl)"
+          >
+            <svg width="12" height="12" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4">
+              <path d="M11 2.5l2.5 2.5L5 13.5H2.5V11L11 2.5z" stroke-linejoin="round"/>
+            </svg>
+          </button>
+        </div>
+
+        <!-- Comment thread anchored to this line -->
+        <div
+          v-else-if="row.kind === 'thread'"
+          class="pid-thread-row pid-rowbox"
+          :class="{ 'pid-rowbox--end': isHunkEnd(idx) }"
+          :data-row-index="idx"
+        >
+          <div class="pid-thread-gutter" />
+          <div class="pid-thread-body">
+            <PrCommentThread
+              :comments="row.thread.comments"
+              :current-user="currentUser"
+              :cwd="cwd"
+              :pr-number="prNumber"
+              :forge-name="forgeName"
+              :can-edit="props.canEditComments"
+              :can-delete="props.canDeleteComments"
+              @reply="(body) => handleReply(row.thread, body)"
+              @edit="handleEdit"
+              @delete="handleDelete"
+              @apply-suggestion="handleApplySuggestion"
+            />
+          </div>
+        </div>
+
+        <!-- Compose box anchored to this line -->
+        <div
+          v-else-if="row.kind === 'compose'"
+          class="pid-thread-row pid-compose-row pid-rowbox"
+          :class="{ 'pid-rowbox--end': isHunkEnd(idx) }"
+          :data-row-index="idx"
+        >
+          <div class="pid-thread-gutter" />
+          <div class="pid-thread-body">
+            <div class="pid-compose">
+              <textarea
+                v-model="composeText"
+                class="pid-textarea"
+                :placeholder="t('pr.inline.composePlaceholder')"
+                rows="3"
+                autofocus
+                @keydown.ctrl.enter.prevent="submitCompose"
+                @keydown.meta.enter.prevent="submitCompose"
+                @keydown.escape="closeCompose"
               />
+              <div class="pid-compose-actions">
+                <button class="pid-cancel-btn" @click="closeCompose">{{ t('pr.inline.cancel') }}</button>
+                <button
+                  class="pid-review-btn"
+                  :disabled="!composeText.trim()"
+                  @click="submitToReview"
+                  :title="reviewDraftCount ? t('pr.inline.addToReviewPending', reviewDraftCount) : t('pr.inline.addToReview')"
+                >
+                  {{ reviewDraftCount ? t('pr.inline.reviewBtnCount', reviewDraftCount) : t('pr.inline.reviewBtn') }}
+                </button>
+                <button
+                  class="pid-submit-btn"
+                  :disabled="!composeText.trim()"
+                  @click="submitCompose"
+                >{{ t('pr.inline.commentBtn') }}</button>
+              </div>
             </div>
           </div>
+        </div>
 
-          <!-- Compose box anchored to this line -->
-          <div
-            v-if="isComposeAnchoredAt(dl)"
-            class="pid-thread-row pid-compose-row"
-          >
-            <div class="pid-thread-gutter" />
-            <div class="pid-thread-body">
-              <div class="pid-compose">
+        <!-- Suggestion editor (v2.13) -->
+        <div
+          v-else-if="row.kind === 'suggest'"
+          class="pid-thread-row pid-suggest-row pid-rowbox"
+          :class="{ 'pid-rowbox--end': isHunkEnd(idx) }"
+          :data-row-index="idx"
+        >
+          <div class="pid-thread-gutter" />
+          <div class="pid-thread-body">
+            <div class="pid-suggest">
+              <div class="pid-suggest-header">
+                <svg width="13" height="13" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4">
+                  <path d="M11 2.5l2.5 2.5L5 13.5H2.5V11L11 2.5z" stroke-linejoin="round"/>
+                </svg>
+                {{ t('pr.inline.suggestTitle') }}
+                <span class="pid-suggest-hint">{{ t('pr.inline.suggestHint') }}</span>
+              </div>
+              <div class="pid-suggest-preview">
+                <span class="pid-suggest-fence">```suggestion</span>
                 <textarea
-                  v-model="composeText"
-                  class="pid-textarea"
-                  :placeholder="t('pr.inline.composePlaceholder')"
+                  v-model="suggestText"
+                  class="pid-textarea pid-suggest-textarea mono"
                   rows="3"
                   autofocus
-                  @keydown.ctrl.enter.prevent="submitCompose"
-                  @keydown.meta.enter.prevent="submitCompose"
-                  @keydown.escape="closeCompose"
+                  @keydown.ctrl.enter.prevent="submitSuggest"
+                  @keydown.meta.enter.prevent="submitSuggest"
+                  @keydown.escape="closeSuggest"
                 />
-                <div class="pid-compose-actions">
-                  <button class="pid-cancel-btn" @click="closeCompose">{{ t('pr.inline.cancel') }}</button>
-                  <button
-                    class="pid-review-btn"
-                    :disabled="!composeText.trim()"
-                    @click="submitToReview"
-                    :title="reviewDraftCount ? t('pr.inline.addToReviewPending', reviewDraftCount) : t('pr.inline.addToReview')"
-                  >
-                    {{ reviewDraftCount ? t('pr.inline.reviewBtnCount', reviewDraftCount) : t('pr.inline.reviewBtn') }}
-                  </button>
-                  <button
-                    class="pid-submit-btn"
-                    :disabled="!composeText.trim()"
-                    @click="submitCompose"
-                  >{{ t('pr.inline.commentBtn') }}</button>
-                </div>
+                <span class="pid-suggest-fence">```</span>
+              </div>
+              <div class="pid-compose-actions">
+                <button class="pid-cancel-btn" @click="closeSuggest">{{ t('pr.inline.cancel') }}</button>
+                <button
+                  class="pid-review-btn"
+                  @click="submitSuggest"
+                  :title="reviewDraftCount ? t('pr.inline.addToReviewPending', reviewDraftCount) : t('pr.inline.addToReview')"
+                >
+                  {{ reviewDraftCount ? t('pr.inline.reviewBtnCount', reviewDraftCount) : t('pr.inline.suggestAddToReview') }}
+                </button>
               </div>
             </div>
           </div>
+        </div>
+      </template>
+    </div>
 
-          <!-- Suggestion editor (v2.13) -->
-          <div
-            v-if="isSuggestAnchoredAt(dl)"
-            class="pid-thread-row pid-suggest-row"
-          >
-            <div class="pid-thread-gutter" />
-            <div class="pid-thread-body">
-              <div class="pid-suggest">
-                <div class="pid-suggest-header">
-                  <svg width="13" height="13" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4">
-                    <path d="M11 2.5l2.5 2.5L5 13.5H2.5V11L11 2.5z" stroke-linejoin="round"/>
-                  </svg>
-                  {{ t('pr.inline.suggestTitle') }}
-                  <span class="pid-suggest-hint">{{ t('pr.inline.suggestHint') }}</span>
+    <!-- A2: virtualized above the threshold — same row markup, only the
+         positioning differs (absolute + translateY instead of normal flow). -->
+    <div v-else ref="scrollContainerRef" class="pid-rows pid-rows--virtual">
+      <div :style="{ height: totalSize + 'px', position: 'relative', width: '100%' }">
+        <div
+          v-for="{ vr, row } in virtualRowsView"
+          :key="'' + vr.key"
+          :data-row-index="vr.index"
+          :ref="(el) => measure(el as Element)"
+          :style="vrStyle(vr)"
+        >
+          <template v-if="row.kind === 'hunk-header'">
+            <div
+              class="pid-hunk-header mono pid-rowbox pid-rowbox--start"
+              :class="{ 'pid-rowbox--end': isHunkEnd(vr.index) }"
+            >
+              <span class="pid-hunk-header-text">{{ diff.hunks[row.hunkIdx].header }}</span>
+              <button
+                v-if="ai.isAvailable.value"
+                class="btn btn--ai pid-hunk-ai"
+                :class="{ 'pid-hunk-ai--active': critiqueOpenIdx === row.hunkIdx }"
+                :disabled="critiqueLoadingIdx === row.hunkIdx"
+                :title="t('prInline.aiCritiqueTooltip')"
+                @click="requestHunkCritique(row.hunkIdx)"
+              >
+                <span v-if="critiqueLoadingIdx === row.hunkIdx">…</span>
+                <span v-else class="pid-ai-label">
+                  <AiSparkle :size="13" />
+                  {{ t('prInline.aiCritiqueButton') }}
+                </span>
+              </button>
+            </div>
+          </template>
+          <template v-else-if="row.kind === 'critique'">
+            <div
+              class="pid-critique pid-rowbox"
+              :class="[critiqueResults[row.hunkIdx] ? verdictClass(critiqueResults[row.hunkIdx]!.verdict) : '', { 'pid-rowbox--end': isHunkEnd(vr.index) }]"
+              role="status"
+              aria-live="polite"
+            >
+              <span class="pid-critique-icon">
+                <template v-if="critiqueResults[row.hunkIdx]">{{ verdictIcon(critiqueResults[row.hunkIdx]!.verdict) }}</template>
+                <AiSparkle v-else :size="14" />
+              </span>
+              <span class="pid-critique-body">
+                <span v-if="critiqueAiError && !critiqueResults[row.hunkIdx]" class="pid-critique-error">{{ critiqueAiError }}</span>
+                <span v-else-if="critiqueLoadingIdx === row.hunkIdx && !critiqueResults[row.hunkIdx]">
+                  {{ t('prInline.aiCritiqueAnalyzing') }}
+                </span>
+                <template v-else-if="critiqueResults[row.hunkIdx]">
+                  <span class="pid-critique-verdict">{{ critiqueResults[row.hunkIdx]!.verdict }}</span>
+                  <span class="pid-critique-summary">{{ critiqueResults[row.hunkIdx]!.summary }}</span>
+                </template>
+              </span>
+              <button
+                v-if="critiqueLoadingIdx !== row.hunkIdx"
+                class="pid-critique-close"
+                @click="dismissCritique"
+                aria-label="Close"
+              >✕</button>
+            </div>
+          </template>
+          <template v-else-if="row.kind === 'line'">
+            <div
+              class="pid-row pid-rowbox"
+              :class="{
+                'pid-row--add': row.dl.type === 'add',
+                'pid-row--del': row.dl.type === 'delete',
+                'pid-row--ctx': row.dl.type === 'context',
+                'pid-row--annotated': annotationsForLine(row.dl).length > 0,
+                'pid-rowbox--start': isHunkStart(vr.index),
+                'pid-rowbox--end': isHunkEnd(vr.index),
+              }"
+            >
+              <div v-if="annotationsForLine(row.dl).length" class="pid-ann">
+                <span
+                  class="pid-ann-icon"
+                  :class="`pid-ann-icon--${annotationLevel(annotationsForLine(row.dl))}`"
+                >{{ ANN_ICONS[annotationLevel(annotationsForLine(row.dl))] }}</span>
+                <div class="pid-ann-tip">
+                  <div
+                    v-for="(a, ai) in annotationsForLine(row.dl)"
+                    :key="ai"
+                    class="pid-ann-tip-item"
+                  >
+                    <div class="pid-ann-tip-head">
+                      <span>{{ ANN_ICONS[a.severity] }}</span>
+                      <span class="pid-ann-tip-title">{{ a.title || a.checkName }}</span>
+                      <span v-if="a.confidence != null" class="pid-ann-tip-confidence">{{ a.confidence }}%</span>
+                    </div>
+                    <div v-if="a.message" class="pid-ann-tip-msg">{{ a.message }}</div>
+                    <div class="pid-ann-tip-src">{{ a.checkName || a.source }}</div>
+                  </div>
                 </div>
-                <div class="pid-suggest-preview">
-                  <span class="pid-suggest-fence">```suggestion</span>
+              </div>
+              <div
+                class="pid-lno mono"
+                :class="{ 'pid-lno--clickable': row.dl.type !== 'add' }"
+                @click="row.dl.type !== 'add' && openCompose(row.hunkIdx, row.lineIdx, row.dl)"
+                :title="row.dl.type !== 'add' ? 'Ajouter un commentaire' : undefined"
+              >
+                <span class="pid-lno-num">{{ row.dl.oldLineNo ?? '' }}</span>
+                <span class="pid-lno-icon">+</span>
+              </div>
+              <div
+                class="pid-lno mono"
+                :class="{ 'pid-lno--clickable': row.dl.type !== 'delete' }"
+                @click="row.dl.type !== 'delete' && openCompose(row.hunkIdx, row.lineIdx, row.dl)"
+                :title="row.dl.type !== 'delete' ? 'Ajouter un commentaire' : undefined"
+              >
+                <span class="pid-lno-num">{{ row.dl.newLineNo ?? '' }}</span>
+                <span class="pid-lno-icon">+</span>
+              </div>
+              <div class="pid-marker mono">
+                {{ row.dl.type === 'add' ? '+' : row.dl.type === 'delete' ? '-' : ' ' }}
+              </div>
+              <div class="pid-content mono" v-html="safeHtml(hl(row.dl.content)) || '&nbsp;'" />
+              <button
+                v-if="row.dl.type !== 'delete'"
+                class="pid-suggest-btn"
+                :title="t('pr.inline.suggestTooltip')"
+                @click.stop="openSuggest(row.hunkIdx, row.lineIdx, row.dl)"
+              >
+                <svg width="12" height="12" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4">
+                  <path d="M11 2.5l2.5 2.5L5 13.5H2.5V11L11 2.5z" stroke-linejoin="round"/>
+                </svg>
+              </button>
+            </div>
+          </template>
+          <template v-else-if="row.kind === 'thread'">
+            <div class="pid-thread-row pid-rowbox" :class="{ 'pid-rowbox--end': isHunkEnd(vr.index) }">
+              <div class="pid-thread-gutter" />
+              <div class="pid-thread-body">
+                <PrCommentThread
+                  :comments="row.thread.comments"
+                  :current-user="currentUser"
+                  :cwd="cwd"
+                  :pr-number="prNumber"
+                  :forge-name="forgeName"
+                  :can-edit="props.canEditComments"
+                  :can-delete="props.canDeleteComments"
+                  @reply="(body) => handleReply(row.thread, body)"
+                  @edit="handleEdit"
+                  @delete="handleDelete"
+                  @apply-suggestion="handleApplySuggestion"
+                />
+              </div>
+            </div>
+          </template>
+          <template v-else-if="row.kind === 'compose'">
+            <div class="pid-thread-row pid-compose-row pid-rowbox" :class="{ 'pid-rowbox--end': isHunkEnd(vr.index) }">
+              <div class="pid-thread-gutter" />
+              <div class="pid-thread-body">
+                <div class="pid-compose">
                   <textarea
-                    v-model="suggestText"
-                    class="pid-textarea pid-suggest-textarea mono"
+                    v-model="composeText"
+                    class="pid-textarea"
+                    :placeholder="t('pr.inline.composePlaceholder')"
                     rows="3"
                     autofocus
-                    @keydown.ctrl.enter.prevent="submitSuggest"
-                    @keydown.meta.enter.prevent="submitSuggest"
-                    @keydown.escape="closeSuggest"
+                    @keydown.ctrl.enter.prevent="submitCompose"
+                    @keydown.meta.enter.prevent="submitCompose"
+                    @keydown.escape="closeCompose"
                   />
-                  <span class="pid-suggest-fence">```</span>
+                  <div class="pid-compose-actions">
+                    <button class="pid-cancel-btn" @click="closeCompose">{{ t('pr.inline.cancel') }}</button>
+                    <button
+                      class="pid-review-btn"
+                      :disabled="!composeText.trim()"
+                      @click="submitToReview"
+                      :title="reviewDraftCount ? t('pr.inline.addToReviewPending', reviewDraftCount) : t('pr.inline.addToReview')"
+                    >
+                      {{ reviewDraftCount ? t('pr.inline.reviewBtnCount', reviewDraftCount) : t('pr.inline.reviewBtn') }}
+                    </button>
+                    <button
+                      class="pid-submit-btn"
+                      :disabled="!composeText.trim()"
+                      @click="submitCompose"
+                    >{{ t('pr.inline.commentBtn') }}</button>
+                  </div>
                 </div>
-                <div class="pid-compose-actions">
-                  <button class="pid-cancel-btn" @click="closeSuggest">{{ t('pr.inline.cancel') }}</button>
-                  <button
-                    class="pid-review-btn"
-                    @click="submitSuggest"
-                    :title="reviewDraftCount ? t('pr.inline.addToReviewPending', reviewDraftCount) : t('pr.inline.addToReview')"
-                  >
-                    {{ reviewDraftCount ? t('pr.inline.reviewBtnCount', reviewDraftCount) : t('pr.inline.suggestAddToReview') }}
-                  </button>
+              </div>
+            </div>
+          </template>
+          <template v-else-if="row.kind === 'suggest'">
+            <div class="pid-thread-row pid-suggest-row pid-rowbox" :class="{ 'pid-rowbox--end': isHunkEnd(vr.index) }">
+              <div class="pid-thread-gutter" />
+              <div class="pid-thread-body">
+                <div class="pid-suggest">
+                  <div class="pid-suggest-header">
+                    <svg width="13" height="13" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4">
+                      <path d="M11 2.5l2.5 2.5L5 13.5H2.5V11L11 2.5z" stroke-linejoin="round"/>
+                    </svg>
+                    {{ t('pr.inline.suggestTitle') }}
+                    <span class="pid-suggest-hint">{{ t('pr.inline.suggestHint') }}</span>
+                  </div>
+                  <div class="pid-suggest-preview">
+                    <span class="pid-suggest-fence">```suggestion</span>
+                    <textarea
+                      v-model="suggestText"
+                      class="pid-textarea pid-suggest-textarea mono"
+                      rows="3"
+                      autofocus
+                      @keydown.ctrl.enter.prevent="submitSuggest"
+                      @keydown.meta.enter.prevent="submitSuggest"
+                      @keydown.escape="closeSuggest"
+                    />
+                    <span class="pid-suggest-fence">```</span>
+                  </div>
+                  <div class="pid-compose-actions">
+                    <button class="pid-cancel-btn" @click="closeSuggest">{{ t('pr.inline.cancel') }}</button>
+                    <button
+                      class="pid-review-btn"
+                      @click="submitSuggest"
+                      :title="reviewDraftCount ? t('pr.inline.addToReviewPending', reviewDraftCount) : t('pr.inline.addToReview')"
+                    >
+                      {{ reviewDraftCount ? t('pr.inline.reviewBtnCount', reviewDraftCount) : t('pr.inline.suggestAddToReview') }}
+                    </button>
+                  </div>
                 </div>
               </div>
             </div>
-          </div>
-        </template>
+          </template>
+        </div>
       </div>
-    </template>
+    </div>
   </div>
 </template>
 
@@ -578,11 +962,33 @@ function handleApplySuggestion(suggestion: string, startLine: number | null, end
   text-align: center;
 }
 
-.pid-hunk {
+/* A2: each hunk used to be wrapped in a single `.pid-hunk` box (border +
+   radius + overflow:hidden). Flattening to a per-row virtualizable list
+   means there's no wrapper element anymore — every row instead carries
+   `.pid-rowbox` (side borders) plus `--start`/`--end` on the first/last row
+   of its hunk (top/bottom border, rounded corners, and the hunk-to-hunk
+   gap), reproducing the same boxed look without a group wrapper. */
+.pid-rows {
+  display: flex;
+  flex-direction: column;
+}
+
+.pid-rowbox {
+  border-left: 1px solid var(--color-border);
+  border-right: 1px solid var(--color-border);
+}
+
+.pid-rowbox--start {
+  border-top: 1px solid var(--color-border);
+  border-top-left-radius: 6px;
+  border-top-right-radius: 6px;
+}
+
+.pid-rowbox--end {
+  border-bottom: 1px solid var(--color-border);
+  border-bottom-left-radius: 6px;
+  border-bottom-right-radius: 6px;
   margin-bottom: 8px;
-  border: 1px solid var(--color-border);
-  border-radius: 6px;
-  overflow: hidden;
 }
 
 .pid-hunk-header {
@@ -746,6 +1152,14 @@ function handleApplySuggestion(suggestion: string, startLine: number | null, end
 .pid-ann-tip-title {
   overflow-wrap: anywhere;
 }
+/* E1 — AI finding confidence (C4 renders real values here) */
+.pid-ann-tip-confidence {
+  margin-left: auto;
+  font-size: 10px;
+  font-weight: 500;
+  color: var(--color-text-muted);
+  flex-shrink: 0;
+}
 .pid-ann-tip-msg {
   margin-top: 2px;
   color: var(--color-text);
diff --git a/apps/desktop/src/components/PrIntelligencePanel.vue b/apps/desktop/src/components/PrIntelligencePanel.vue
index fe989ea2..ecdc028c 100644
--- a/apps/desktop/src/components/PrIntelligencePanel.vue
+++ b/apps/desktop/src/components/PrIntelligencePanel.vue
@@ -25,6 +25,8 @@ import type {
   PullRequestDetail,
   GitDiff,
 } from "../utils/backend";
+import type { ReviewFinding } from "../composables/usePrPreReview";
+import type { LineAnnotation } from "../composables/prAnnotations";
 import { useI18n } from "../composables/useI18n";
 
 const { t } = useI18n();
@@ -45,14 +47,31 @@ const props = defineProps<{
   /** File review history keyed by path. */
   fileHistory: Record<string, PrFileHistory>;
   fileHistoryLoading: boolean;
+  /** AI pre-review findings (C4, v3.6.0) — confidence-sorted, already
+   *  threshold/cap/dismissal-filtered by `usePrPanel`. */
+  preReviewFindings: ReviewFinding[];
+  preReviewProgress: { done: number; total: number };
+  preReviewRunning: boolean;
+  /** Static heuristic flags (E2, v3.6.0) — computed by
+   *  `useReviewIntelligence`'s `computeStaticFlags`, not locally anymore. */
+  staticFlags: LineAnnotation[];
 }>();
 
 const emit = defineEmits<{
   (e: "load-conflict-preview"): void;
   (e: "load-hotspots"): void;
   (e: "load-file-history"): void;
+  (e: "dismiss-finding", id: string): void;
+  (e: "jump-to-finding", path: string, line: number): void;
 }>();
 
+/** Map a finding's open severity scale onto the existing error/warn/info
+ *  row modifiers (`.pi-ai-row--*`) so it visually matches the static-flags
+ *  list above it. */
+function findingRowSeverity(sev: ReviewFinding["severity"]): "error" | "warn" | "info" {
+  return sev === "risk" ? "error" : sev === "suggestion" ? "warn" : "info";
+}
+
 // ─── Review scope ────────────────────────────────────────
 const scope = computed(() => {
   const changedFiles = props.prDetail.changedFiles;
@@ -100,50 +119,13 @@ function hotspotTier(score: number): "high" | "medium" | "low" {
   return "low";
 }
 
-// ─── AI suggestion detection (static analysis) ───────────
-interface AiFlag {
-  file: string;
-  reason: string;
-  severity: "info" | "warn" | "error";
-}
-
-const aiFlags = computed<AiFlag[]>(() => {
-  const flags: AiFlag[] = [];
-  for (const diff of props.prDiffFiles) {
-    const totalAdded = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === "add").length, 0);
-    const totalDeleted = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === "delete").length, 0);
-
-    if (totalAdded + totalDeleted > 200) {
-      flags.push({ file: diff.path, reason: t("pr.intel.flagBigFile", totalAdded + totalDeleted), severity: "warn" });
-    }
-
-    // Detect potential breaking changes: removed exports, deleted function signatures
-    const deletedLines = diff.hunks.flatMap((h) => h.lines.filter((l) => l.type === "delete").map((l) => l.content));
-    const hasExportRemoval = deletedLines.some((l) => /^\s*(export\s+(default|const|function|class)|module\.exports|def |pub fn |public )/.test(l));
-    if (hasExportRemoval) {
-      flags.push({ file: diff.path, reason: t("pr.intel.flagExportRemoved"), severity: "error" });
-    }
-
-    // Detect config/env file changes
-    if (/\.(env|config|yaml|yml|toml|json|lock)$/.test(diff.path)) {
-      flags.push({ file: diff.path, reason: t("pr.intel.flagConfigChange"), severity: "info" });
-    }
-
-    // Detect migration files
-    if (/migrat|schema\.sql|\.sql$/.test(diff.path.toLowerCase())) {
-      flags.push({ file: diff.path, reason: t("pr.intel.flagDbMigration"), severity: "warn" });
-    }
-
-    // Large single hunk
-    for (const hunk of diff.hunks) {
-      if (hunk.lines.length > 100) {
-        flags.push({ file: diff.path, reason: t("pr.intel.flagBigHunk", hunk.lines.length), severity: "info" });
-        break; // Only once per file
-      }
-    }
-  }
-  return flags;
-});
+// ─── AI suggestion detection (static analysis, E2, v3.6.0) ───────────
+// `staticFlags` (prop) is computed by `useReviewIntelligence.computeStaticFlags`
+// — this component only maps its `LineAnnotation` severity scale onto the
+// existing `.pi-ai-row--error/warn/info` visual modifiers.
+function flagRowSeverity(sev: LineAnnotation["severity"]): "error" | "warn" | "info" {
+  return sev === "failure" ? "error" : sev === "warning" ? "warn" : "info";
+}
 
 // Auto-load hotspots and file history when component mounts
 // (conflict preview is on-demand since it requires git fetch)
@@ -451,21 +433,21 @@ watch(() => props.prDiffFiles, (files) => {
         <span class="pi-badge pi-badge--ai">{{ t('pr.intel.staticBadge') }}</span>
       </header>
 
-      <div v-if="aiFlags.length === 0" class="pi-empty">
+      <div v-if="staticFlags.length === 0" class="pi-empty">
         {{ t('pr.intel.noAnomalies') }}
       </div>
 
       <div v-else class="pi-ai-list">
         <div
-          v-for="(flag, i) in aiFlags"
+          v-for="(flag, i) in staticFlags"
           :key="i"
           class="pi-ai-row"
-          :class="`pi-ai-row--${flag.severity}`"
+          :class="`pi-ai-row--${flagRowSeverity(flag.severity)}`"
         >
           <span class="pi-ai-icon" aria-hidden="true">
             <!-- siren for error, triangle-bang for warn, info-circle for info -->
             <svg
-              v-if="flag.severity === 'error'"
+              v-if="flagRowSeverity(flag.severity) === 'error'"
               width="13"
               height="13"
               viewBox="0 0 16 16"
@@ -479,7 +461,7 @@ watch(() => props.prDiffFiles, (files) => {
               <path d="M8 5v4M8 11v.01" />
             </svg>
             <svg
-              v-else-if="flag.severity === 'warn'"
+              v-else-if="flagRowSeverity(flag.severity) === 'warn'"
               width="13"
               height="13"
               viewBox="0 0 16 16"
@@ -508,13 +490,59 @@ watch(() => props.prDiffFiles, (files) => {
             </svg>
           </span>
           <div class="pi-ai-content">
-            <span class="pi-ai-file mono">{{ flag.file.split('/').pop() }}</span>
-            <span class="pi-ai-reason">{{ flag.reason }}</span>
+            <span class="pi-ai-file mono">{{ flag.path.split('/').pop() }}</span>
+            <span class="pi-ai-reason">{{ flag.title }}</span>
           </div>
         </div>
       </div>
     </section>
 
+    <!-- ── AI Pre-Review Findings (C4, v3.6.0) ──────────────── -->
+    <section class="pi-section">
+      <header class="pi-section-header">
+        <span class="pi-section-icon pi-section-icon--ai" aria-hidden="true">
+          <svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M6.5 2l1 2.8 2.8 1-2.8 1-1 2.8-1-2.8-2.8-1 2.8-1z" />
+            <path d="M11.5 9l.6 1.6 1.6.6-1.6.6-.6 1.6-.6-1.6-1.6-.6 1.6-.6z" />
+          </svg>
+        </span>
+        <h3 class="pi-section-title">{{ t('pr.preReview.title') }}</h3>
+        <span v-if="preReviewRunning" class="pi-badge pi-badge--ai">
+          {{ t('pr.preReview.progress', preReviewProgress.done, preReviewProgress.total) }}
+        </span>
+      </header>
+
+      <div v-if="preReviewRunning && preReviewFindings.length === 0" class="pi-empty">
+        {{ t('pr.preReview.running') }}
+      </div>
+      <div v-else-if="preReviewFindings.length === 0" class="pi-empty">
+        {{ t('pr.preReview.empty') }}
+      </div>
+
+      <div v-else class="pi-ai-list">
+        <div
+          v-for="f in preReviewFindings"
+          :key="f.id"
+          class="pi-ai-row pi-finding-row"
+          :class="`pi-ai-row--${findingRowSeverity(f.severity)}`"
+        >
+          <button type="button" class="pi-finding-jump" @click="emit('jump-to-finding', f.path, f.line)">
+            <div class="pi-ai-content">
+              <span class="pi-ai-file mono">{{ f.path.split('/').pop() }}:{{ f.line }}</span>
+              <span class="pi-ai-reason">{{ f.title }}</span>
+            </div>
+          </button>
+          <span class="pi-finding-confidence">{{ f.confidence }}%</span>
+          <button
+            type="button"
+            class="pi-finding-dismiss"
+            :title="t('pr.preReview.dismiss')"
+            @click="emit('dismiss-finding', f.id)"
+          >✕</button>
+        </div>
+      </div>
+    </section>
+
     <!-- ── File Review History ─────────────────────────────── -->
     <section class="pi-section">
       <header class="pi-section-header">
@@ -1042,6 +1070,42 @@ watch(() => props.prDiffFiles, (files) => {
   font-size: var(--font-size-sm);
 }
 
+/* ─── AI pre-review findings (C4, v3.6.0) ─────────────────── */
+.pi-finding-row {
+  align-items: center;
+}
+.pi-finding-jump {
+  flex: 1;
+  min-width: 0;
+  text-align: left;
+  background: transparent;
+  border: none;
+  padding: 0;
+  cursor: pointer;
+  color: inherit;
+  font: inherit;
+}
+.pi-finding-confidence {
+  flex-shrink: 0;
+  font-size: var(--font-size-xs);
+  color: var(--color-text-muted);
+}
+.pi-finding-dismiss {
+  flex-shrink: 0;
+  background: transparent;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  color: var(--color-text-muted);
+  width: 20px;
+  height: 20px;
+  line-height: 1;
+  cursor: pointer;
+}
+.pi-finding-dismiss:hover {
+  color: var(--color-danger);
+  border-color: var(--color-danger);
+}
+
 /* ─── File history ──────────────────────────────────────── */
 .pi-history-list {
   display: flex;
diff --git a/apps/desktop/src/components/PullRequestPanel.vue b/apps/desktop/src/components/PullRequestPanel.vue
index 513dd487..c931ea1a 100644
--- a/apps/desktop/src/components/PullRequestPanel.vue
+++ b/apps/desktop/src/components/PullRequestPanel.vue
@@ -840,6 +840,10 @@ watch(() => props.cwd, () => {
                   :hotspots-loading="hotspotsLoading"
                   :file-history="fileHistory"
                   :file-history-loading="fileHistoryLoading"
+                  :pre-review-findings="[]"
+                  :pre-review-progress="{ done: 0, total: 0 }"
+                  :pre-review-running="false"
+                  :static-flags="[]"
                   @load-conflict-preview="loadConflictPreview"
                   @load-hotspots="loadHotspots"
                   @load-file-history="loadFileHistory"
diff --git a/apps/desktop/src/components/SettingsPanel.vue b/apps/desktop/src/components/SettingsPanel.vue
index aa6ebb69..edaafce1 100644
--- a/apps/desktop/src/components/SettingsPanel.vue
+++ b/apps/desktop/src/components/SettingsPanel.vue
@@ -154,6 +154,11 @@ interface Settings {
   aiModelByProvider: Partial<Record<AIProvider, string>>;
   aiOllamaUrl: string;
   aiOllamaModel: string;
+  // Review AI (E3, v3.6.0) — opt-in pre-review pass + PR summary settings.
+  reviewAiPreReview: boolean;
+  reviewAiConfidenceThreshold: number;
+  reviewAiMaxFindings: number;
+  reviewAiSummary: boolean;
   // Today view — last active surface persisted between openings (v2.9 / Phase 2)
   // Only "inbox" and "team" are live surfaces after Phase 2.
   launchpadActiveTab: "inbox" | "wip" | "prs" | "issues" | "team";
@@ -241,6 +246,10 @@ const defaultSettings: Settings = {
   aiModelByProvider: {},
   aiOllamaUrl: "http://localhost:11434",
   aiOllamaModel: "codellama",
+  reviewAiPreReview: false,
+  reviewAiConfidenceThreshold: 60,
+  reviewAiMaxFindings: 15,
+  reviewAiSummary: false,
   blameAlgorithm: "histogram",
   launchpadActiveTab: "inbox",
   launchpadTeamTabEnabled: true,
@@ -2650,6 +2659,58 @@ function deleteReleaseNoteTemplate(id: string) {
               </div>
             </template>
 
+            <!-- ─── Review AI (E3, v3.6.0) ─────────────────── -->
+            <div class="sp-section-divider sp-section-divider--inner"></div>
+            <div class="sp-group">
+              <div class="sp-group__head">
+                <div class="sp-group__head-text">
+                  <span class="sp-group__label">{{ t('settings.reviewAi.title') }}</span>
+                  <span class="sp-group__sublabel">{{ t('settings.reviewAi.hint') }}</span>
+                </div>
+              </div>
+
+              <div class="sp-row sp-row--checkbox">
+                <label class="sp-checkbox-label" for="setting-review-ai-pre-review">
+                  <input id="setting-review-ai-pre-review" type="checkbox" class="sp-checkbox"
+                    :checked="settings.reviewAiPreReview"
+                    @change="updateSetting('reviewAiPreReview', ($event.target as HTMLInputElement).checked)" />
+                  <span>{{ t('settings.reviewAi.preReview') }}</span>
+                </label>
+                <span class="sp-hint">{{ t('settings.reviewAi.preReviewHint') }}</span>
+              </div>
+
+              <template v-if="settings.reviewAiPreReview">
+                <div class="sp-row">
+                  <label class="sp-label" for="setting-review-ai-threshold">{{ t('settings.reviewAi.threshold') }}</label>
+                  <div class="sp-range-row">
+                    <input id="setting-review-ai-threshold" type="range" class="sp-range" min="0" max="100" step="5"
+                      :value="settings.reviewAiConfidenceThreshold"
+                      @input="updateSetting('reviewAiConfidenceThreshold', Number(($event.target as HTMLInputElement).value))" />
+                    <span class="sp-range-value">{{ settings.reviewAiConfidenceThreshold }}</span>
+                  </div>
+                  <span class="sp-hint">{{ t('settings.reviewAi.thresholdHint') }}</span>
+                </div>
+
+                <div class="sp-row">
+                  <label class="sp-label" for="setting-review-ai-cap">{{ t('settings.reviewAi.cap') }}</label>
+                  <input id="setting-review-ai-cap" type="number" class="sp-input" min="1" max="50" step="1"
+                    :value="settings.reviewAiMaxFindings"
+                    @input="updateSetting('reviewAiMaxFindings', Number(($event.target as HTMLInputElement).value))" />
+                  <span class="sp-hint">{{ t('settings.reviewAi.capHint') }}</span>
+                </div>
+              </template>
+
+              <div class="sp-row sp-row--checkbox">
+                <label class="sp-checkbox-label" for="setting-review-ai-summary">
+                  <input id="setting-review-ai-summary" type="checkbox" class="sp-checkbox"
+                    :checked="settings.reviewAiSummary"
+                    @change="updateSetting('reviewAiSummary', ($event.target as HTMLInputElement).checked)" />
+                  <span>{{ t('settings.reviewAi.summary') }}</span>
+                </label>
+                <span class="sp-hint">{{ t('settings.reviewAi.summaryHint') }}</span>
+              </div>
+            </div>
+
             <!-- ─── Prompt Presets (v2.13) ─────────────────── -->
             <div class="sp-section-divider sp-section-divider--inner"></div>
             <div class="sp-group">
diff --git a/apps/desktop/src/components/__tests__/PrInlineDiff.test.ts b/apps/desktop/src/components/__tests__/PrInlineDiff.test.ts
new file mode 100644
index 00000000..1f270fc0
--- /dev/null
+++ b/apps/desktop/src/components/__tests__/PrInlineDiff.test.ts
@@ -0,0 +1,120 @@
+/**
+ * PrInlineDiff.vue — flat row model + virtualization (Task A2, v3.6.0).
+ *
+ * Mounted with the native `createApp` (no @vue/test-utils dep), mirroring
+ * LaunchpadView.test / MergeEditor.test.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { createApp, nextTick, type App } from "vue";
+import PrInlineDiff from "../PrInlineDiff.vue";
+import type { GitDiff, DiffHunk, DiffLine } from "../../utils/backend";
+import type { LineAnnotation } from "../../composables/prAnnotations";
+
+function line(type: DiffLine["type"], content: string, oldLineNo?: number, newLineNo?: number): DiffLine {
+  return { type, content, oldLineNo, newLineNo };
+}
+
+/** A single hunk with `n` context lines — used to push the row count past
+ *  the virtualization threshold with one big hunk (the scenario the spec's
+ *  success metric targets: "5 000-line file's diff DOM is bounded"). */
+function bigHunk(n: number): DiffHunk {
+  const lines: DiffLine[] = [];
+  for (let i = 1; i <= n; i++) lines.push(line("context", `line ${i}`, i, i));
+  return { header: `@@ -1,${n} +1,${n} @@`, oldStart: 1, oldCount: n, newStart: 1, newCount: n, lines };
+}
+
+function smallDiff(): GitDiff {
+  return {
+    path: "src/foo.ts",
+    hunks: [
+      {
+        header: "@@ -1,3 +1,3 @@",
+        oldStart: 1, oldCount: 3, newStart: 1, newCount: 3,
+        lines: [
+          line("context", "unchanged", 1, 1),
+          line("delete", "old value", 2, undefined),
+          line("add", "new value", undefined, 2),
+        ],
+      },
+    ],
+  };
+}
+
+interface MountResult { app: App; container: HTMLDivElement; vm: any }
+
+function mountDiff(props: Record<string, unknown>): MountResult {
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const app = createApp(PrInlineDiff as any, props);
+  const vm = app.mount(container);
+  return { app, container, vm };
+}
+
+function unmount({ app, container }: MountResult) {
+  app.unmount();
+  if (container.parentNode) container.parentNode.removeChild(container);
+}
+
+describe("PrInlineDiff — flat row model", () => {
+  let mounted: MountResult | null = null;
+
+  afterEach(() => {
+    if (mounted) unmount(mounted);
+    mounted = null;
+  });
+
+  it("renders the full DOM (non-virtual) for a small diff, boxed per hunk", async () => {
+    mounted = mountDiff({ diff: smallDiff(), filePath: "src/foo.ts", comments: [] });
+    await nextTick();
+    expect(mounted.container.querySelector(".pid-rows--virtual")).toBeNull();
+    const rowEls = mounted.container.querySelectorAll("[data-row-index]");
+    // hunk-header + 3 lines = 4 rows for this fixture.
+    expect(rowEls.length).toBe(4);
+    expect(rowEls[0].classList.contains("pid-rowbox--start")).toBe(true);
+    expect(rowEls[rowEls.length - 1].classList.contains("pid-rowbox--end")).toBe(true);
+  });
+
+  it("renders CI annotation gutter icons", async () => {
+    const annotations: LineAnnotation[] = [
+      { source: "ci", checkName: "lint", severity: "warning", line: 2, endLine: 2, side: "RIGHT", title: "warn", message: "", path: "src/foo.ts" },
+    ];
+    mounted = mountDiff({ diff: smallDiff(), filePath: "src/foo.ts", comments: [], annotations });
+    await nextTick();
+    expect(mounted.container.querySelector(".pid-ann-icon--warning")).not.toBeNull();
+  });
+
+  it("switches to the virtualized path once row count crosses the threshold, bounding the DOM", async () => {
+    const diff: GitDiff = { path: "src/big.ts", hunks: [bigHunk(5000)] };
+    mounted = mountDiff({ diff, filePath: "src/big.ts", comments: [] });
+    await nextTick();
+    await nextTick();
+    expect(mounted.container.querySelector(".pid-rows--virtual")).not.toBeNull();
+    // jsdom has no real layout (zero-size viewport), so the virtualizer may
+    // report an empty visible window — the point of this assertion is that
+    // the DOM never grows anywhere near the full 5001-row count, not a
+    // specific viewport-dependent number.
+    const rowEls = mounted.container.querySelectorAll("[data-row-index]");
+    expect(rowEls.length).toBeLessThan(200);
+  });
+
+  it("exposes scrollToHunk / scrollToLine / rows for keyboard nav (B1)", async () => {
+    mounted = mountDiff({ diff: smallDiff(), filePath: "src/foo.ts", comments: [] });
+    await nextTick();
+    // `defineExpose`d refs are unwrapped on the public mount-instance proxy
+    // (same auto-unwrap as template access) — so `currentRowIdx` reads as a
+    // plain number here, not `{ value }`.
+    const exposed = mounted.vm as unknown as {
+      scrollToHunk: (i: number) => void;
+      scrollToLine: (i: number) => void;
+      rows: { kind: string }[];
+      currentRowIdx: number;
+    };
+    expect(typeof exposed.scrollToHunk).toBe("function");
+    expect(typeof exposed.scrollToLine).toBe("function");
+    expect(exposed.rows.map((r) => r.kind)).toEqual(["hunk-header", "line", "line", "line"]);
+    exposed.scrollToHunk(0);
+    expect(exposed.currentRowIdx).toBe(0);
+    exposed.scrollToLine(2);
+    expect(exposed.currentRowIdx).toBe(2);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/prAiLocale.test.ts b/apps/desktop/src/composables/__tests__/prAiLocale.test.ts
new file mode 100644
index 00000000..e8ae10bf
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/prAiLocale.test.ts
@@ -0,0 +1,23 @@
+/**
+ * prAiLocale — verifier fix (v3.6.0): the AI pre-review/summary system
+ * prompts only mapped locale === "fr" ? "French" : "English", so es/pt-BR/
+ * zh-CN users silently got English-language findings and summaries. Shared
+ * helper so `usePrPreReview.ts` and `usePrSummary.ts` can't drift.
+ */
+import { describe, it, expect } from "vitest";
+import { localeToAiLanguage } from "../prAiLocale";
+
+describe("localeToAiLanguage", () => {
+  it("maps all 5 product locales to their AI prompt language name", () => {
+    expect(localeToAiLanguage("en")).toBe("English");
+    expect(localeToAiLanguage("fr")).toBe("French");
+    expect(localeToAiLanguage("es")).toBe("Spanish");
+    expect(localeToAiLanguage("pt-BR")).toBe("Brazilian Portuguese");
+    expect(localeToAiLanguage("zh-CN")).toBe("Simplified Chinese");
+  });
+
+  it("falls back to English for an unrecognized locale", () => {
+    expect(localeToAiLanguage("xx")).toBe("English");
+    expect(localeToAiLanguage(undefined)).toBe("English");
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/prAnnotations.test.ts b/apps/desktop/src/composables/__tests__/prAnnotations.test.ts
new file mode 100644
index 00000000..65eb7240
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/prAnnotations.test.ts
@@ -0,0 +1,124 @@
+import { describe, it, expect } from "vitest";
+import { fromCIAnnotation, fromFinding, annotationsByLine, worstSeverity, type LineAnnotation } from "../prAnnotations";
+import type { CIAnnotation } from "../../utils/backend";
+import type { ReviewFinding } from "../usePrPreReview";
+
+function ciAnn(overrides: Partial<CIAnnotation> = {}): CIAnnotation {
+  return {
+    checkName: "lint",
+    path: "a.ts",
+    startLine: 3,
+    endLine: 3,
+    level: "warning",
+    title: "unused var",
+    message: "",
+    ...overrides,
+  };
+}
+
+function ann(overrides: Partial<LineAnnotation>): LineAnnotation {
+  return {
+    source: "ai",
+    path: "a.ts",
+    line: 1,
+    side: "RIGHT",
+    severity: "suggestion",
+    title: "t",
+    ...overrides,
+  };
+}
+
+describe("fromCIAnnotation", () => {
+  it("maps a CIAnnotation onto the shared LineAnnotation model", () => {
+    const a = ciAnn({ startLine: 5, endLine: 7, level: "failure", title: "boom", message: "m", checkName: "ci-job" });
+    expect(fromCIAnnotation(a)).toEqual({
+      source: "ci",
+      path: "a.ts",
+      line: 5,
+      side: "RIGHT",
+      endLine: 7,
+      severity: "failure",
+      title: "boom",
+      message: "m",
+      checkName: "ci-job",
+    });
+  });
+});
+
+describe("fromFinding", () => {
+  it("maps a ReviewFinding onto the shared LineAnnotation model, carrying confidence + id", () => {
+    const f: ReviewFinding = {
+      id: "abc123", path: "a.ts", line: 4, side: "RIGHT",
+      severity: "risk", confidence: 82, title: "possible null deref", detail: "explain",
+    };
+    expect(fromFinding(f)).toEqual({
+      source: "ai",
+      path: "a.ts",
+      line: 4,
+      side: "RIGHT",
+      severity: "risk",
+      confidence: 82,
+      title: "possible null deref",
+      message: "explain",
+      id: "abc123",
+    });
+  });
+});
+
+describe("merged annotation stream (CI + AI)", () => {
+  it("keeps CI and AI annotations distinct by source when grouped together", () => {
+    const ci = fromCIAnnotation({ checkName: "lint", path: "a.ts", startLine: 2, endLine: 2, level: "warning", title: "w", message: "" });
+    const aiFinding: ReviewFinding = { id: "1", path: "a.ts", line: 2, side: "RIGHT", severity: "risk", confidence: 90, title: "r", detail: "" };
+    const ai = fromFinding(aiFinding);
+    const map = annotationsByLine([ci, ai]);
+    const atLine2 = map.get("RIGHT:2") ?? [];
+    expect(atLine2.map((a) => a.source).sort()).toEqual(["ai", "ci"]);
+  });
+});
+
+describe("annotationsByLine", () => {
+  it("keys by side + line so LEFT and RIGHT don't merge on the same number", () => {
+    const map = annotationsByLine([
+      ann({ side: "RIGHT", line: 10, title: "right" }),
+      ann({ side: "LEFT", line: 10, title: "left" }),
+    ]);
+    expect(map.get("RIGHT:10")?.map((a) => a.title)).toEqual(["right"]);
+    expect(map.get("LEFT:10")?.map((a) => a.title)).toEqual(["left"]);
+  });
+
+  it("expands a range annotation line-by-line", () => {
+    const map = annotationsByLine([ann({ line: 5, endLine: 7 })]);
+    expect(map.has("RIGHT:5")).toBe(true);
+    expect(map.has("RIGHT:6")).toBe(true);
+    expect(map.has("RIGHT:7")).toBe(true);
+    expect(map.has("RIGHT:8")).toBe(false);
+  });
+
+  it("caps a huge range at 20 lines by default", () => {
+    const map = annotationsByLine([ann({ line: 1, endLine: 1000 })]);
+    expect(map.has("RIGHT:20")).toBe(true);
+    expect(map.has("RIGHT:21")).toBe(false);
+  });
+
+  it("respects a custom cap", () => {
+    const map = annotationsByLine([ann({ line: 1, endLine: 1000 })], 5);
+    expect(map.has("RIGHT:5")).toBe(true);
+    expect(map.has("RIGHT:6")).toBe(false);
+  });
+});
+
+describe("worstSeverity", () => {
+  it("failure/risk outranks warning/suggestion which outranks notice/nit", () => {
+    expect(worstSeverity([ann({ severity: "notice" }), ann({ severity: "failure" }), ann({ severity: "warning" })])).toBe("failure");
+    expect(worstSeverity([ann({ severity: "nit" }), ann({ severity: "risk" })])).toBe("risk");
+    expect(worstSeverity([ann({ severity: "notice" }), ann({ severity: "suggestion" })])).toBe("suggestion");
+  });
+
+  it("returns 'notice' for an empty list", () => {
+    expect(worstSeverity([])).toBe("notice");
+  });
+
+  it("falls back to the first annotation's severity when none are recognized", () => {
+    expect(worstSeverity([ann({ severity: "mystery" })])).toBe("mystery");
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrCache-dismissed.test.ts b/apps/desktop/src/composables/__tests__/usePrCache-dismissed.test.ts
new file mode 100644
index 00000000..8366ed85
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrCache-dismissed.test.ts
@@ -0,0 +1,65 @@
+/**
+ * Task C2 (v3.6.0) — local dismissal memory for AI pre-review findings,
+ * keyed per repo.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+
+let usePrCache: typeof import("../usePrCache").usePrCache;
+let _resetPrCacheForTesting: typeof import("../usePrCache")._resetPrCacheForTesting;
+
+beforeEach(async () => {
+  localStorage.clear();
+  const mod = await import("../usePrCache");
+  usePrCache = mod.usePrCache;
+  _resetPrCacheForTesting = mod._resetPrCacheForTesting;
+  _resetPrCacheForTesting();
+});
+
+const CWD = "/repo/a";
+
+describe("usePrCache — dismissed findings (C2)", () => {
+  it("getDismissed returns an empty set for an unknown repo", () => {
+    expect(usePrCache().getDismissed(CWD)).toEqual(new Set());
+  });
+
+  it("addDismissed / getDismissed round-trip", () => {
+    const c = usePrCache();
+    c.addDismissed(CWD, "src::unused variable");
+    expect(c.getDismissed(CWD)).toEqual(new Set(["src::unused variable"]));
+  });
+
+  it("addDismissed accumulates distinct classes", () => {
+    const c = usePrCache();
+    c.addDismissed(CWD, "a");
+    c.addDismissed(CWD, "b");
+    expect(c.getDismissed(CWD)).toEqual(new Set(["a", "b"]));
+  });
+
+  it("addDismissed is idempotent for the same class", () => {
+    const c = usePrCache();
+    c.addDismissed(CWD, "a");
+    c.addDismissed(CWD, "a");
+    expect(c.getDismissed(CWD)).toEqual(new Set(["a"]));
+  });
+
+  it("dismissal memory is scoped per repo", () => {
+    const c = usePrCache();
+    c.addDismissed(CWD, "a");
+    expect(c.getDismissed("/repo/other")).toEqual(new Set());
+  });
+
+  it("persists across a module reset (cold start)", () => {
+    usePrCache().addDismissed(CWD, "a");
+    _resetPrCacheForTesting();
+    expect(usePrCache().getDismissed(CWD)).toEqual(new Set(["a"]));
+  });
+
+  it("is pruned by age on load", () => {
+    usePrCache().addDismissed(CWD, "a");
+    const raw = JSON.parse(localStorage.getItem("gitwand-pr-cache")!);
+    for (const k of Object.keys(raw.dismissedFindings)) raw.dismissedFindings[k].ts = 0;
+    localStorage.setItem("gitwand-pr-cache", JSON.stringify(raw));
+    _resetPrCacheForTesting();
+    expect(usePrCache().getDismissed(CWD)).toEqual(new Set());
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrCache-draft.test.ts b/apps/desktop/src/composables/__tests__/usePrCache-draft.test.ts
new file mode 100644
index 00000000..4e8e8133
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrCache-draft.test.ts
@@ -0,0 +1,58 @@
+/**
+ * Task B3 (v3.6.0) — pending review draft persistence in the SWR cache.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import type { PendingReviewComment } from "../../utils/backend";
+
+let usePrCache: typeof import("../usePrCache").usePrCache;
+let detailKey: typeof import("../usePrCache").detailKey;
+let _resetPrCacheForTesting: typeof import("../usePrCache")._resetPrCacheForTesting;
+
+beforeEach(async () => {
+  localStorage.clear();
+  const mod = await import("../usePrCache");
+  usePrCache = mod.usePrCache;
+  detailKey = mod.detailKey;
+  _resetPrCacheForTesting = mod._resetPrCacheForTesting;
+  _resetPrCacheForTesting();
+});
+
+const KEY = () => detailKey("/repo/a", 7);
+
+function comment(path: string): PendingReviewComment {
+  return { path, line: 1, side: "RIGHT", body: "nit" };
+}
+
+describe("usePrCache — pending review draft (B3)", () => {
+  it("setDraft / getDraft round-trip", () => {
+    const c = usePrCache();
+    c.setDraft(KEY(), [comment("a.ts")]);
+    expect(c.getDraft(KEY())).toEqual([comment("a.ts")]);
+  });
+
+  it("getDraft returns null for an unknown key", () => {
+    expect(usePrCache().getDraft(KEY())).toBeNull();
+  });
+
+  it("clearDraft removes the entry", () => {
+    const c = usePrCache();
+    c.setDraft(KEY(), [comment("a.ts")]);
+    c.clearDraft(KEY());
+    expect(c.getDraft(KEY())).toBeNull();
+  });
+
+  it("persists across a module reset (cold start)", () => {
+    usePrCache().setDraft(KEY(), [comment("a.ts"), comment("b.ts")]);
+    _resetPrCacheForTesting();
+    expect(usePrCache().getDraft(KEY())?.length).toBe(2);
+  });
+
+  it("is pruned by age on load", () => {
+    usePrCache().setDraft(KEY(), [comment("a.ts")]);
+    const raw = JSON.parse(localStorage.getItem("gitwand-pr-cache")!);
+    for (const k of Object.keys(raw.drafts)) raw.drafts[k].ts = 0;
+    localStorage.setItem("gitwand-pr-cache", JSON.stringify(raw));
+    _resetPrCacheForTesting();
+    expect(usePrCache().getDraft(KEY())).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrCache-findings.test.ts b/apps/desktop/src/composables/__tests__/usePrCache-findings.test.ts
new file mode 100644
index 00000000..25b67cf7
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrCache-findings.test.ts
@@ -0,0 +1,46 @@
+/**
+ * Task C3 (v3.6.0) — AI pre-review findings cache, keyed `${detailKey}@${headSha}`.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import type { ReviewFinding } from "../usePrPreReview";
+
+let usePrCache: typeof import("../usePrCache").usePrCache;
+let detailKey: typeof import("../usePrCache").detailKey;
+let _resetPrCacheForTesting: typeof import("../usePrCache")._resetPrCacheForTesting;
+
+beforeEach(async () => {
+  localStorage.clear();
+  const mod = await import("../usePrCache");
+  usePrCache = mod.usePrCache;
+  detailKey = mod.detailKey;
+  _resetPrCacheForTesting = mod._resetPrCacheForTesting;
+  _resetPrCacheForTesting();
+});
+
+function finding(): ReviewFinding {
+  return { id: "1", path: "a.ts", line: 1, side: "RIGHT", severity: "nit", confidence: 50, title: "t", detail: "" };
+}
+
+function keyAt(sha: string) {
+  return `${detailKey("/repo", 1)}@${sha}`;
+}
+
+describe("usePrCache — findings by headSha (C3)", () => {
+  it("setFindings / getFindings round-trip", () => {
+    const c = usePrCache();
+    c.setFindings(keyAt("sha1"), [finding()]);
+    expect(c.getFindings(keyAt("sha1"))).toEqual([finding()]);
+  });
+
+  it("a different headSha misses the cache", () => {
+    const c = usePrCache();
+    c.setFindings(keyAt("sha1"), [finding()]);
+    expect(c.getFindings(keyAt("sha2"))).toBeNull();
+  });
+
+  it("persists across a module reset (cold start)", () => {
+    usePrCache().setFindings(keyAt("sha1"), [finding()]);
+    _resetPrCacheForTesting();
+    expect(usePrCache().getFindings(keyAt("sha1"))).toEqual([finding()]);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrCache-summary.test.ts b/apps/desktop/src/composables/__tests__/usePrCache-summary.test.ts
new file mode 100644
index 00000000..6e240664
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrCache-summary.test.ts
@@ -0,0 +1,39 @@
+/**
+ * Task D1 (v3.6.0) — AI PR summary cache, keyed `${detailKey}@${headSha}`.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+
+let usePrCache: typeof import("../usePrCache").usePrCache;
+let detailKey: typeof import("../usePrCache").detailKey;
+let _resetPrCacheForTesting: typeof import("../usePrCache")._resetPrCacheForTesting;
+
+beforeEach(async () => {
+  localStorage.clear();
+  const mod = await import("../usePrCache");
+  usePrCache = mod.usePrCache;
+  detailKey = mod.detailKey;
+  _resetPrCacheForTesting = mod._resetPrCacheForTesting;
+  _resetPrCacheForTesting();
+});
+
+const keyAt = (sha: string) => `${detailKey("/repo", 1)}@${sha}`;
+
+describe("usePrCache — PR summary (D1)", () => {
+  it("setSummary / getSummary round-trip", () => {
+    const c = usePrCache();
+    c.setSummary(keyAt("sha1"), "What: x. Why: y.");
+    expect(c.getSummary(keyAt("sha1"))).toBe("What: x. Why: y.");
+  });
+
+  it("a different headSha misses the cache", () => {
+    const c = usePrCache();
+    c.setSummary(keyAt("sha1"), "summary");
+    expect(c.getSummary(keyAt("sha2"))).toBeNull();
+  });
+
+  it("persists across a module reset (cold start)", () => {
+    usePrCache().setSummary(keyAt("sha1"), "summary");
+    _resetPrCacheForTesting();
+    expect(usePrCache().getSummary(keyAt("sha1"))).toBe("summary");
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrCache-viewed.test.ts b/apps/desktop/src/composables/__tests__/usePrCache-viewed.test.ts
new file mode 100644
index 00000000..e08cbb10
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrCache-viewed.test.ts
@@ -0,0 +1,68 @@
+/**
+ * Task B2 (v3.6.0) — client-side viewed-file state in the SWR cache, with
+ * re-push (headSha change) invalidation at whole-PR granularity.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+
+let usePrCache: typeof import("../usePrCache").usePrCache;
+let detailKey: typeof import("../usePrCache").detailKey;
+let _resetPrCacheForTesting: typeof import("../usePrCache")._resetPrCacheForTesting;
+
+beforeEach(async () => {
+  localStorage.clear();
+  const mod = await import("../usePrCache");
+  usePrCache = mod.usePrCache;
+  detailKey = mod.detailKey;
+  _resetPrCacheForTesting = mod._resetPrCacheForTesting;
+  _resetPrCacheForTesting();
+});
+
+const KEY = () => detailKey("/repo/a", 42);
+
+describe("usePrCache — viewed-file state (B2)", () => {
+  it("setViewed / getViewed round-trip", () => {
+    const c = usePrCache();
+    c.setViewed(KEY(), "sha1", ["a.ts", "b.ts"]);
+    expect(c.getViewed(KEY())).toEqual({ headSha: "sha1", paths: ["a.ts", "b.ts"] });
+  });
+
+  it("getViewed returns null for an unknown key", () => {
+    expect(usePrCache().getViewed(KEY())).toBeNull();
+  });
+
+  it("toggleViewed adds a path, then removes it on a second toggle", () => {
+    const c = usePrCache();
+    c.toggleViewed(KEY(), "sha1", "a.ts");
+    expect(c.getViewed(KEY())?.paths).toEqual(["a.ts"]);
+    c.toggleViewed(KEY(), "sha1", "a.ts");
+    expect(c.getViewed(KEY())?.paths).toEqual([]);
+  });
+
+  it("toggleViewed with a new headSha clears prior paths before applying the toggle", () => {
+    const c = usePrCache();
+    c.setViewed(KEY(), "sha1", ["a.ts", "b.ts"]);
+    c.toggleViewed(KEY(), "sha2", "c.ts"); // re-push — new head SHA
+    const v = c.getViewed(KEY());
+    expect(v?.headSha).toBe("sha2");
+    expect(v?.paths).toEqual(["c.ts"]); // a.ts/b.ts from the old head are gone
+  });
+
+  it("persists across a module reset (cold start)", () => {
+    usePrCache().setViewed(KEY(), "sha1", ["a.ts"]);
+    _resetPrCacheForTesting();
+    expect(usePrCache().getViewed(KEY())).toEqual({ headSha: "sha1", paths: ["a.ts"] });
+  });
+
+  it("is pruned/evicted by the existing age/LRU machinery", () => {
+    const c = usePrCache();
+    c.setViewed(KEY(), "sha1", ["a.ts"]);
+    expect(localStorage.getItem("gitwand-pr-cache")).toContain("viewed");
+    // Age pruning runs on load — simulate a stale write by editing the ts
+    // directly in storage, then reload the module state from it.
+    const raw = JSON.parse(localStorage.getItem("gitwand-pr-cache")!);
+    for (const k of Object.keys(raw.viewed)) raw.viewed[k].ts = 0;
+    localStorage.setItem("gitwand-pr-cache", JSON.stringify(raw));
+    _resetPrCacheForTesting();
+    expect(usePrCache().getViewed(KEY())).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrFindingFilter.test.ts b/apps/desktop/src/composables/__tests__/usePrFindingFilter.test.ts
new file mode 100644
index 00000000..63dd5fac
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrFindingFilter.test.ts
@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { normalizeFindingClass, filterFindings } from "../usePrFindingFilter";
+import type { ReviewFinding } from "../usePrPreReview";
+
+function finding(overrides: Partial<ReviewFinding> = {}): ReviewFinding {
+  return {
+    id: "id1", path: "src/a.ts", line: 1, side: "RIGHT",
+    severity: "suggestion", confidence: 70, title: "unused variable", detail: "",
+    ...overrides,
+  };
+}
+
+describe("normalizeFindingClass", () => {
+  it("collapses digit variance in the title", () => {
+    const a = normalizeFindingClass(finding({ title: "unused variable x2" }));
+    const b = normalizeFindingClass(finding({ title: "unused variable x7" }));
+    expect(a).toBe(b);
+  });
+
+  it("uses the file's dirname, not the full path", () => {
+    const a = normalizeFindingClass(finding({ path: "src/a.ts", line: 5 }));
+    const b = normalizeFindingClass(finding({ path: "src/a.ts", line: 99 }));
+    expect(a).toBe(b);
+  });
+
+  it("differs across directories with the same title", () => {
+    const a = normalizeFindingClass(finding({ path: "src/a.ts" }));
+    const b = normalizeFindingClass(finding({ path: "test/a.ts" }));
+    expect(a).not.toBe(b);
+  });
+
+  it("is case-insensitive on the title", () => {
+    const a = normalizeFindingClass(finding({ title: "Unused Variable" }));
+    const b = normalizeFindingClass(finding({ title: "unused variable" }));
+    expect(a).toBe(b);
+  });
+});
+
+describe("filterFindings", () => {
+  it("drops findings below the threshold", () => {
+    const all = [finding({ id: "a", confidence: 40 }), finding({ id: "b", confidence: 80 })];
+    const out = filterFindings(all, { threshold: 60, cap: 10, dismissed: new Set() });
+    expect(out.map((f) => f.id)).toEqual(["b"]);
+  });
+
+  it("caps at the top-N by confidence", () => {
+    const all = [
+      finding({ id: "a", confidence: 90 }),
+      finding({ id: "b", confidence: 70 }),
+      finding({ id: "c", confidence: 80 }),
+    ];
+    const out = filterFindings(all, { threshold: 0, cap: 2, dismissed: new Set() });
+    expect(out.map((f) => f.id)).toEqual(["a", "c"]);
+  });
+
+  it("removes a dismissed class regardless of confidence", () => {
+    const dismissedFinding = finding({ id: "a", title: "dismiss me", confidence: 95 });
+    const dismissed = new Set([normalizeFindingClass(dismissedFinding)]);
+    const out = filterFindings([dismissedFinding, finding({ id: "b" })], { threshold: 0, cap: 10, dismissed });
+    expect(out.map((f) => f.id)).toEqual(["b"]);
+  });
+
+  it("returns [] when everything is below threshold or dismissed", () => {
+    const out = filterFindings([finding({ confidence: 10 })], { threshold: 50, cap: 10, dismissed: new Set() });
+    expect(out).toEqual([]);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-comment-capability.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-comment-capability.test.ts
new file mode 100644
index 00000000..2e7dd2d8
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-comment-capability.test.ts
@@ -0,0 +1,84 @@
+/**
+ * Task F2 (v3.6.0) — Azure comment edit/delete capability.
+ *
+ * `usePrPanel` exposes `forgeSupportsCommentEdit`/`forgeSupportsCommentDelete`
+ * computeds so the UI (PrCommentThread, via PrInlineDiff) can hide the edit/
+ * delete affordance instead of calling into a forge that throws
+ * `ForgeNotImplementedError`.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const gitRemoteInfo = vi.fn();
+const ghPrDetail = vi.fn();
+const ghPrComments = vi.fn();
+const azPrDetail = vi.fn();
+const azPrComments = vi.fn();
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: (...a: unknown[]) => gitRemoteInfo(...a),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    azPrDetail: (...a: unknown[]) => azPrDetail(...a),
+    azPrComments: (...a: unknown[]) => azPrComments(...a),
+  };
+});
+
+import { usePrPanel } from "../usePrPanel";
+import { ForgeNotImplementedError } from "../forge/types";
+
+function fakeDetail() {
+  return {
+    number: 1, title: "t", body: "", state: "open", author: "a", branch: "b", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 0, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha: "sha1",
+  };
+}
+
+describe("usePrPanel — comment edit/delete capability (F2)", () => {
+  beforeEach(() => {
+    gitRemoteInfo.mockReset().mockResolvedValue({ url: "", host: "github.com", provider: "github", owner: "o", repo: "r" });
+    ghPrDetail.mockReset().mockResolvedValue(fakeDetail());
+    ghPrComments.mockReset().mockResolvedValue([]);
+    azPrDetail.mockReset().mockResolvedValue(fakeDetail());
+    azPrComments.mockReset().mockResolvedValue([]);
+  });
+
+  it("is true for GitHub", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    expect(p.forgeSupportsCommentEdit.value).toBe(true);
+    expect(p.forgeSupportsCommentDelete.value).toBe(true);
+  });
+
+  it("is false for Azure", async () => {
+    gitRemoteInfo.mockResolvedValue({ url: "https://dev.azure.com/o/r", host: "dev.azure.com", provider: "azure", owner: "o", repo: "r" });
+    const p = usePrPanel(ref("/repo"));
+    await p.loadRemote();
+    await p.selectPr({ number: 1 } as any);
+    expect(p.forge.value.name).toBe("azure");
+    expect(p.forgeSupportsCommentEdit.value).toBe(false);
+    expect(p.forgeSupportsCommentDelete.value).toBe(false);
+  });
+
+  it("handleEditComment swallows ForgeNotImplementedError without setting `error`", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    (p.forge.value as any).updateComment = vi.fn().mockRejectedValue(new ForgeNotImplementedError("azure", "updateComment"));
+    await p.handleEditComment(1, "new body");
+    expect(p.error.value).toBeNull();
+  });
+
+  it("handleDeleteComment swallows ForgeNotImplementedError without setting `error`", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    (p.forge.value as any).deleteComment = vi.fn().mockRejectedValue(new ForgeNotImplementedError("azure", "deleteComment"));
+    await p.handleDeleteComment(1);
+    expect(p.error.value).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-draft.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-draft.test.ts
new file mode 100644
index 00000000..6647298e
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-draft.test.ts
@@ -0,0 +1,83 @@
+/**
+ * Task B3 (v3.6.0) — pending review draft persists across detail close/
+ * reopen and PR switches, and clears on successful submit.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const ghPrDetail = vi.fn();
+const ghPrComments = vi.fn();
+const ghPrListReviews = vi.fn();
+const ghPrSubmitReview = vi.fn();
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: vi.fn(async () => ({ url: "", host: "github.com", owner: "o", repo: "r" })),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    ghPrListReviews: (...a: unknown[]) => ghPrListReviews(...a),
+    ghPrSubmitReview: (...a: unknown[]) => ghPrSubmitReview(...a),
+  };
+});
+
+import { usePrPanel } from "../usePrPanel";
+import { usePrCache, detailKey, _resetPrCacheForTesting } from "../usePrCache";
+
+function fakeDetail(n: number) {
+  return {
+    number: n, title: "t", body: "", state: "open", author: "a", branch: "b", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 0, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha: "sha1",
+  };
+}
+
+describe("usePrPanel — pending review draft (B3)", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    ghPrDetail.mockReset().mockImplementation(async (_cwd: string, n: number) => fakeDetail(n));
+    ghPrComments.mockReset().mockResolvedValue([]);
+    ghPrListReviews.mockReset().mockResolvedValue([]);
+    ghPrSubmitReview.mockReset().mockResolvedValue({});
+  });
+
+  it("handleAddToReview persists the draft to the cache", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    p.handleAddToReview({ path: "a.ts", line: 1, side: "RIGHT", body: "nit" });
+    expect(p.draftCount.value).toBe(1);
+    expect(usePrCache().getDraft(detailKey("/repo", 1))?.length).toBe(1);
+  });
+
+  it("selectPr restores the draft for the same PR from the cache", async () => {
+    usePrCache().setDraft(detailKey("/repo", 1), [{ path: "a.ts", line: 1, side: "RIGHT", body: "nit" }]);
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    expect(p.draftReviewComments.value.length).toBe(1);
+  });
+
+  it("handleSubmitReview clears the draft on success", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    p.handleAddToReview({ path: "a.ts", line: 1, side: "RIGHT", body: "nit" });
+    await p.handleSubmitReview({ event: "COMMENT", body: "", comments: p.draftReviewComments.value });
+    expect(p.draftCount.value).toBe(0);
+    expect(usePrCache().getDraft(detailKey("/repo", 1))).toBeNull();
+  });
+
+  it("switching PRs isolates drafts by key", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    p.handleAddToReview({ path: "a.ts", line: 1, side: "RIGHT", body: "nit" });
+
+    await p.selectPr({ number: 2 } as any);
+    expect(p.draftCount.value).toBe(0); // PR 2 has no draft
+
+    await p.selectPr({ number: 1 } as any);
+    expect(p.draftCount.value).toBe(1); // PR 1's draft survived the round trip
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-findings-render.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-findings-render.test.ts
new file mode 100644
index 00000000..de4edf85
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-findings-render.test.ts
@@ -0,0 +1,86 @@
+/**
+ * Task C4 (v3.6.0) — merged annotation stream (CI + AI) per file, and
+ * dismissing a finding removes it from the stream and the filtered list.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const ghPrDetail = vi.fn();
+const ghPrComments = vi.fn();
+const ghPrListReviews = vi.fn();
+const ghCheckAnnotations = vi.fn();
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: vi.fn(async () => ({ url: "", host: "github.com", owner: "o", repo: "r" })),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    ghPrListReviews: (...a: unknown[]) => ghPrListReviews(...a),
+    ghCheckAnnotations: (...a: unknown[]) => ghCheckAnnotations(...a),
+  };
+});
+
+const settingsRef = ref<Record<string, unknown>>({
+  reviewAiPreReview: false, reviewAiConfidenceThreshold: 0, reviewAiMaxFindings: 15,
+});
+vi.mock("../useSettings", () => ({ useSettings: () => ({ settings: settingsRef }) }));
+vi.mock("../useAIProvider", () => ({
+  useAIProvider: () => ({ isAvailable: ref(true), rawPrompt: vi.fn(async () => "[]") }),
+}));
+
+import { usePrPanel } from "../usePrPanel";
+import { usePrCache, detailKey, _resetPrCacheForTesting } from "../usePrCache";
+
+function fakeDetail() {
+  return {
+    number: 1, title: "t", body: "", state: "open", author: "a", branch: "b", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 1, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha: "sha1",
+  };
+}
+
+describe("usePrPanel — merged findings render (C4)", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    // AI findings only ever render when pre-review is opted in — a cache
+    // hit still respects that gate (see `maybeRunPreReview`).
+    settingsRef.value = { reviewAiPreReview: true, reviewAiConfidenceThreshold: 0, reviewAiMaxFindings: 15 };
+    ghPrDetail.mockReset().mockResolvedValue(fakeDetail());
+    ghPrComments.mockReset().mockResolvedValue([]);
+    ghPrListReviews.mockReset().mockResolvedValue([]);
+    ghCheckAnnotations.mockReset().mockResolvedValue([
+      { checkName: "lint", path: "a.ts", startLine: 2, endLine: 2, level: "warning", title: "ci finding", message: "" },
+    ]);
+  });
+
+  it("merges CI annotations and cached AI findings for a file, distinct by source", async () => {
+    usePrCache().setFindings(`${detailKey("/repo", 1)}@sha1`, [
+      { id: "1", path: "a.ts", line: 3, side: "RIGHT", severity: "risk", confidence: 90, title: "ai finding", detail: "" },
+    ]);
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await p.loadAnnotations();
+    await new Promise((r) => setTimeout(r, 5)); // let the headSha watcher paint the cache hit
+
+    const merged = p.mergedAnnotationsByFile.value["a.ts"];
+    expect(merged.map((a) => a.source).sort()).toEqual(["ai", "ci"]);
+  });
+
+  it("dismissing a finding removes it from preReviewFindings", async () => {
+    usePrCache().setFindings(`${detailKey("/repo", 1)}@sha1`, [
+      { id: "1", path: "a.ts", line: 3, side: "RIGHT", severity: "risk", confidence: 90, title: "dismiss me", detail: "" },
+    ]);
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await new Promise((r) => setTimeout(r, 5));
+    expect(p.preReviewFindings.value).toHaveLength(1);
+
+    p.dismissFinding("1");
+    expect(p.preReviewFindings.value).toHaveLength(0);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-lazy-diff.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-lazy-diff.test.ts
new file mode 100644
index 00000000..10ccbbfc
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-lazy-diff.test.ts
@@ -0,0 +1,121 @@
+/**
+ * Task A1 (v3.6.0) — lazy per-file diff parse. `getPRDiff` stays a single
+ * fetch, but the raw unified diff is only *indexed* (cheap) up front; the
+ * expensive hunk/line parse runs once per file, only when selected.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitFileCount: vi.fn(async () => 0),
+    gitRemoteInfo: vi.fn(async () => ({ url: "", host: "github.com", owner: "o", repo: "r" })),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDiff: vi.fn(),
+  };
+});
+
+import { ghPrDiff } from "@/utils/backend";
+import { indexDiffFiles, parseFileDiff, parseUnifiedDiff, usePrPanel } from "../usePrPanel";
+
+const THREE_FILE_DIFF = [
+  "diff --git a/a.ts b/a.ts",
+  "index 111..222 100644",
+  "--- a/a.ts",
+  "+++ b/a.ts",
+  "@@ -1,2 +1,2 @@",
+  " context a",
+  "-old a",
+  "+new a",
+  "diff --git a/b.ts b/b.ts",
+  "index 333..444 100644",
+  "--- a/b.ts",
+  "+++ b/b.ts",
+  "@@ -1,3 +1,3 @@",
+  " context b",
+  "",
+  "-old b",
+  "+new b",
+  "diff --git a/c.ts b/c.ts",
+  "index 555..666 100644",
+  "--- a/c.ts",
+  "+++ b/c.ts",
+  "@@ -1,1 +1,1 @@",
+  "-old c",
+  "+new c",
+].join("\n");
+
+describe("indexDiffFiles", () => {
+  it("splits a raw multi-file diff into per-file slices with correct b/ paths", () => {
+    const slices = indexDiffFiles(THREE_FILE_DIFF);
+    expect(slices.map((s) => s.path)).toEqual(["a.ts", "b.ts", "c.ts"]);
+    for (const s of slices) {
+      expect(s.raw.startsWith(`diff --git a/${s.path} b/${s.path}`)).toBe(true);
+    }
+  });
+
+  it("returns [] for an empty diff", () => {
+    expect(indexDiffFiles("")).toEqual([]);
+    expect(indexDiffFiles("   ")).toEqual([]);
+  });
+});
+
+describe("parseFileDiff", () => {
+  it("matches parseUnifiedDiff's per-file output (regression parity)", () => {
+    const expected = parseUnifiedDiff(THREE_FILE_DIFF);
+    const slices = indexDiffFiles(THREE_FILE_DIFF);
+    const actual = slices.map((s) => parseFileDiff(s.raw));
+    expect(actual).toEqual(expected);
+  });
+
+  it("classifies an empty-string context line as context, not add/delete", () => {
+    const slice = indexDiffFiles(THREE_FILE_DIFF)[1]; // b.ts has a blank context line
+    const parsed = parseFileDiff(slice.raw);
+    const blank = parsed.hunks[0].lines.find((l) => l.content === "" && l.type !== undefined);
+    expect(blank?.type).toBe("context");
+  });
+});
+
+describe("usePrPanel — lazy diff parse wiring", () => {
+  beforeEach(() => {
+    vi.mocked(ghPrDiff).mockReset();
+  });
+
+  it("after loadDiff, only the first file has hunks; others are shells", async () => {
+    vi.mocked(ghPrDiff).mockResolvedValue(THREE_FILE_DIFF);
+    const cwd = ref("/repo");
+    const p = usePrPanel(cwd);
+    (p as any).selectedPr.value = { number: 1 } as any;
+    await (p as any).loadDiff();
+
+    const files = p.prDiffFiles.value;
+    expect(files.map((f) => f.path)).toEqual(["a.ts", "b.ts", "c.ts"]);
+    expect(files[0].hunks.length).toBeGreaterThan(0);
+    expect(files[1].hunks).toEqual([]);
+    expect(files[2].hunks).toEqual([]);
+  });
+
+  it("selecting a second file parses it exactly once", async () => {
+    vi.mocked(ghPrDiff).mockResolvedValue(THREE_FILE_DIFF);
+    const cwd = ref("/repo");
+    const p = usePrPanel(cwd);
+    (p as any).selectedPr.value = { number: 1 } as any;
+    await (p as any).loadDiff();
+
+    p.selectedDiffFile.value = "b.ts";
+    await Promise.resolve();
+    const parsedOnce = p.prDiffFiles.value.find((f) => f.path === "b.ts");
+    expect(parsedOnce?.hunks.length).toBeGreaterThan(0);
+
+    // Re-selecting must not re-parse (identity of the hunks array is stable).
+    const hunksRef = parsedOnce?.hunks;
+    p.selectedDiffFile.value = "a.ts";
+    await Promise.resolve();
+    p.selectedDiffFile.value = "b.ts";
+    await Promise.resolve();
+    const again = p.prDiffFiles.value.find((f) => f.path === "b.ts");
+    expect(again?.hunks).toBe(hunksRef);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-lineAnnotations.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-lineAnnotations.test.ts
new file mode 100644
index 00000000..c8676c56
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-lineAnnotations.test.ts
@@ -0,0 +1,61 @@
+/**
+ * Task E1 (v3.6.0) — `lineAnnotationsByFile` converts CI annotations onto
+ * the shared `LineAnnotation` model at the `usePrPanel` boundary, without
+ * changing `annotationsByFile`'s existing CIAnnotation[] shape (still used
+ * for the file-sidebar badge count).
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const ghPrDetail = vi.fn();
+const ghPrComments = vi.fn();
+const ghPrListReviews = vi.fn();
+const ghCheckAnnotations = vi.fn();
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: vi.fn(async () => ({ url: "", host: "github.com", owner: "o", repo: "r" })),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    ghPrListReviews: (...a: unknown[]) => ghPrListReviews(...a),
+    ghCheckAnnotations: (...a: unknown[]) => ghCheckAnnotations(...a),
+  };
+});
+
+import { usePrPanel } from "../usePrPanel";
+
+function fakeDetail() {
+  return {
+    number: 1, title: "t", body: "", state: "open", author: "a", branch: "b", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 0, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha: "sha1",
+  };
+}
+
+describe("usePrPanel — lineAnnotationsByFile (E1)", () => {
+  beforeEach(() => {
+    ghPrDetail.mockReset().mockResolvedValue(fakeDetail());
+    ghPrComments.mockReset().mockResolvedValue([]);
+    ghPrListReviews.mockReset().mockResolvedValue([]);
+    ghCheckAnnotations.mockReset().mockResolvedValue([
+      { checkName: "lint", path: "a.ts", startLine: 3, endLine: 3, level: "warning", title: "unused", message: "" },
+    ]);
+  });
+
+  it("converts CI annotations to LineAnnotation[] keyed by path", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await p.loadAnnotations();
+    expect(p.lineAnnotationsByFile.value["a.ts"]).toEqual([
+      { source: "ci", path: "a.ts", line: 3, side: "RIGHT", endLine: 3, severity: "warning", title: "unused", message: "", checkName: "lint" },
+    ]);
+    // The original CIAnnotation[]-shaped map is untouched (still used for badges).
+    expect(p.annotationsByFile.value["a.ts"]).toEqual([
+      { checkName: "lint", path: "a.ts", startLine: 3, endLine: 3, level: "warning", title: "unused", message: "" },
+    ]);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-prereview.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-prereview.test.ts
new file mode 100644
index 00000000..0bbe1041
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-prereview.test.ts
@@ -0,0 +1,134 @@
+/**
+ * Task C3 (v3.6.0) — `usePrPanel` orchestration of the pre-review pass:
+ * opt-in, cache-first, cancellable on PR switch.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const ghPrDetail = vi.fn();
+const ghPrComments = vi.fn();
+const ghPrListReviews = vi.fn();
+const ghPrDiff = vi.fn();
+const getGitBlame = vi.fn();
+const rawPromptMock = vi.fn();
+const isAvailableRef = { value: true };
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: vi.fn(async () => ({ url: "", host: "github.com", owner: "o", repo: "r" })),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    ghPrListReviews: (...a: unknown[]) => ghPrListReviews(...a),
+    ghPrDiff: (...a: unknown[]) => ghPrDiff(...a),
+    getGitBlame: (...a: unknown[]) => getGitBlame(...a),
+  };
+});
+
+vi.mock("../useAIProvider", () => ({
+  useAIProvider: () => ({
+    isAvailable: isAvailableRef,
+    rawPrompt: (...a: unknown[]) => rawPromptMock(...a),
+  }),
+}));
+
+// Isolate settings from the real localStorage-backed singleton so each test
+// controls `reviewAiPreReview` independently.
+const settingsRef = ref<Record<string, unknown>>({
+  reviewAiPreReview: false,
+  reviewAiConfidenceThreshold: 60,
+  reviewAiMaxFindings: 15,
+});
+vi.mock("../useSettings", () => ({
+  useSettings: () => ({ settings: settingsRef }),
+}));
+
+import { usePrPanel } from "../usePrPanel";
+import { usePrCache, detailKey, _resetPrCacheForTesting } from "../usePrCache";
+
+const RAW_DIFF = [
+  "diff --git a/a.ts b/a.ts",
+  "index 111..222 100644",
+  "--- a/a.ts",
+  "+++ b/a.ts",
+  "@@ -1,1 +1,2 @@",
+  " context",
+  "+new line",
+].join("\n");
+
+function fakeDetail(headSha: string) {
+  return {
+    number: 1, title: "t", body: "", state: "open", author: "a", branch: "b", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 1, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha,
+  };
+}
+
+describe("usePrPanel — pre-review orchestration (C3)", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    settingsRef.value = { reviewAiPreReview: false, reviewAiConfidenceThreshold: 60, reviewAiMaxFindings: 15 };
+    isAvailableRef.value = true;
+    ghPrDetail.mockReset().mockResolvedValue(fakeDetail("sha1"));
+    ghPrComments.mockReset().mockResolvedValue([]);
+    ghPrListReviews.mockReset().mockResolvedValue([]);
+    ghPrDiff.mockReset().mockResolvedValue(RAW_DIFF);
+    getGitBlame.mockReset().mockResolvedValue([]);
+    rawPromptMock.mockReset().mockResolvedValue('[{"line": 1, "title": "f", "confidence": 90}]');
+  });
+
+  it("disabled setting: zero rawPrompt calls", async () => {
+    settingsRef.value.reviewAiPreReview = false;
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await new Promise((r) => setTimeout(r, 5));
+    expect(rawPromptMock).not.toHaveBeenCalled();
+    expect(p.preReviewFindings.value).toEqual([]);
+  });
+
+  it("enabled + cache hit: zero compute, findings painted instantly", async () => {
+    settingsRef.value.reviewAiPreReview = true;
+    usePrCache().setFindings(`${detailKey("/repo", 1)}@sha1`, [
+      { id: "1", path: "a.ts", line: 1, side: "RIGHT", severity: "risk", confidence: 95, title: "cached", detail: "" },
+    ]);
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await new Promise((r) => setTimeout(r, 5));
+    expect(rawPromptMock).not.toHaveBeenCalled();
+    expect(p.preReviewFindings.value.map((f) => f.title)).toEqual(["cached"]);
+  });
+
+  it("enabled + miss: runs and populates findings", async () => {
+    settingsRef.value.reviewAiPreReview = true;
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await new Promise((r) => setTimeout(r, 20));
+    expect(rawPromptMock).toHaveBeenCalledTimes(1);
+    expect(p.preReviewFindings.value.map((f) => f.title)).toEqual(["f"]);
+    // Now cached for next time.
+    expect(usePrCache().getFindings(`${detailKey("/repo", 1)}@sha1`)?.length).toBe(1);
+  });
+
+  it("PR switch aborts the in-flight run", async () => {
+    settingsRef.value.reviewAiPreReview = true;
+    let resolveRawPrompt: (v: string) => void = () => {};
+    rawPromptMock.mockImplementation(() => new Promise((resolve) => { resolveRawPrompt = resolve; }));
+    ghPrDetail.mockImplementation(async (_cwd: string, n: number) => fakeDetail(n === 1 ? "sha1" : "sha2"));
+
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await new Promise((r) => setTimeout(r, 5)); // let the queue start, blocked on rawPrompt
+
+    await p.selectPr({ number: 2 } as any);
+    resolveRawPrompt('[{"line": 1, "title": "stale", "confidence": 90}]');
+    await new Promise((r) => setTimeout(r, 10));
+
+    // The stale finding from PR 1's aborted run must never reach PR 2's state.
+    expect(p.preReviewFindings.value.map((f) => f.title)).not.toContain("stale");
+    expect(usePrCache().getFindings(`${detailKey("/repo", 1)}@sha1`)).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-revalidation.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-revalidation.test.ts
new file mode 100644
index 00000000..093fcdc8
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-revalidation.test.ts
@@ -0,0 +1,115 @@
+/**
+ * Task A3 (v3.6.0) — slim detail revalidation to the 3 hot-path calls
+ * (`getPR` + `listComments` + `listReviews`). `getCIChecks` defers to the
+ * Checks/Diff tab, `gitFileCount` to the Intelligence tab, `listIssueComments`
+ * to the Info tab.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const ghPrDetail = vi.fn();
+const ghPrChecks = vi.fn();
+const ghPrComments = vi.fn();
+const ghPrIssueComments = vi.fn();
+const ghPrListReviews = vi.fn();
+const gitFileCount = vi.fn();
+const ghPrDiff = vi.fn(async (..._args: unknown[]) => "");
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: vi.fn(async () => ({ url: "", host: "github.com", owner: "o", repo: "r" })),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrChecks: (...a: unknown[]) => ghPrChecks(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    ghPrIssueComments: (...a: unknown[]) => ghPrIssueComments(...a),
+    ghPrListReviews: (...a: unknown[]) => ghPrListReviews(...a),
+    gitFileCount: (...a: unknown[]) => gitFileCount(...a),
+    ghPrDiff: (...a: unknown[]) => ghPrDiff(...a),
+  };
+});
+
+import { usePrPanel } from "../usePrPanel";
+
+function fakeDetail() {
+  return {
+    number: 1, title: "t", body: "", state: "open", author: "a", branch: "b", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 0, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha: "abc",
+  };
+}
+
+describe("usePrPanel — slim detail revalidation (A3)", () => {
+  beforeEach(() => {
+    ghPrDetail.mockReset().mockResolvedValue(fakeDetail());
+    ghPrChecks.mockReset().mockResolvedValue([]);
+    ghPrComments.mockReset().mockResolvedValue([]);
+    ghPrIssueComments.mockReset().mockResolvedValue([]);
+    ghPrListReviews.mockReset().mockResolvedValue([]);
+    gitFileCount.mockReset().mockResolvedValue(0);
+  });
+
+  it("selectPr issues exactly the 3 hot-path calls, not checks/issueComments/fileCount", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+
+    expect(ghPrDetail).toHaveBeenCalledTimes(1);
+    expect(ghPrComments).toHaveBeenCalledTimes(1);
+    expect(ghPrListReviews).toHaveBeenCalledTimes(1);
+    expect(ghPrChecks).not.toHaveBeenCalled();
+    expect(ghPrIssueComments).not.toHaveBeenCalled();
+    expect(gitFileCount).not.toHaveBeenCalled();
+  });
+
+  it("switching to the checks tab loads CI checks exactly once", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+
+    p.detailTab.value = "checks";
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(ghPrChecks).toHaveBeenCalledTimes(1);
+
+    p.detailTab.value = "info";
+    await Promise.resolve();
+    p.detailTab.value = "checks";
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(ghPrChecks).toHaveBeenCalledTimes(1); // still once — cached
+  });
+
+  it("switching to the info tab loads issue comments exactly once", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+
+    p.detailTab.value = "diff";
+    await Promise.resolve();
+    p.detailTab.value = "info";
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(ghPrIssueComments).toHaveBeenCalledTimes(1);
+
+    p.detailTab.value = "diff";
+    await Promise.resolve();
+    p.detailTab.value = "info";
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(ghPrIssueComments).toHaveBeenCalledTimes(1);
+  });
+
+  it("switching to the intelligence tab loads the repo file count exactly once", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+
+    p.detailTab.value = "intelligence";
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(gitFileCount).toHaveBeenCalledTimes(1);
+    expect(p.totalRepoFiles.value).toBe(0);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-review-admin.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-review-admin.test.ts
new file mode 100644
index 00000000..0111898a
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-review-admin.test.ts
@@ -0,0 +1,109 @@
+/**
+ * Task B4 (v3.6.0) — dismiss review + request reviewers.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const gitRemoteInfo = vi.fn();
+const ghPrDetail = vi.fn();
+const ghPrComments = vi.fn();
+const ghPrListReviews = vi.fn();
+const ghDismissReview = vi.fn();
+const ghRequestReviewers = vi.fn();
+const glGetMr = vi.fn();
+const glMrNotes = vi.fn();
+const glListReviews = vi.fn();
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: (...a: unknown[]) => gitRemoteInfo(...a),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    ghPrListReviews: (...a: unknown[]) => ghPrListReviews(...a),
+    ghDismissReview: (...a: unknown[]) => ghDismissReview(...a),
+    ghRequestReviewers: (...a: unknown[]) => ghRequestReviewers(...a),
+    glGetMr: (...a: unknown[]) => glGetMr(...a),
+    glMrNotes: (...a: unknown[]) => glMrNotes(...a),
+    glListReviews: (...a: unknown[]) => glListReviews(...a),
+  };
+});
+
+import { usePrPanel } from "../usePrPanel";
+import { ForgeNotImplementedError } from "../forge/types";
+
+function fakeDetail() {
+  return {
+    number: 1, title: "t", body: "", state: "open", author: "a", branch: "b", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 0, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha: "sha1",
+  };
+}
+
+describe("usePrPanel — dismiss review / request reviewers (B4)", () => {
+  beforeEach(() => {
+    gitRemoteInfo.mockReset().mockResolvedValue({ url: "", host: "github.com", provider: "github", owner: "o", repo: "r" });
+    ghPrDetail.mockReset().mockResolvedValue(fakeDetail());
+    ghPrComments.mockReset().mockResolvedValue([]);
+    ghPrListReviews.mockReset().mockResolvedValue([]);
+    ghDismissReview.mockReset().mockResolvedValue(undefined);
+    ghRequestReviewers.mockReset().mockResolvedValue(undefined);
+    glGetMr.mockReset().mockResolvedValue(fakeDetail());
+    glMrNotes.mockReset().mockResolvedValue([]);
+    glListReviews.mockReset().mockResolvedValue([]);
+  });
+
+  it("forgeSupportsDismissReview / forgeSupportsRequestReviewers are true on GitHub", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    expect(p.forgeSupportsDismissReview.value).toBe(true);
+    expect(p.forgeSupportsRequestReviewers.value).toBe(true);
+  });
+
+  it("handleRequestReviewers calls the forge and refreshes the detail", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    ghPrDetail.mockResolvedValue({ ...fakeDetail(), reviewers: ["alice"] });
+    await p.handleRequestReviewers(["alice"]);
+    expect(ghRequestReviewers).toHaveBeenCalledWith("/repo", 1, ["alice"]);
+    expect(p.prDetail.value?.reviewers).toEqual(["alice"]);
+  });
+
+  it("handleRequestReviewers is a no-op with an empty login list", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await p.handleRequestReviewers([]);
+    expect(ghRequestReviewers).not.toHaveBeenCalled();
+  });
+
+  it("handleDismissReview calls the forge and refreshes reviews", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    ghPrListReviews.mockResolvedValue([{ id: 1, state: "DISMISSED" }]);
+    await p.handleDismissReview(7);
+    expect(ghDismissReview).toHaveBeenCalledWith("/repo", 1, 7, undefined);
+    expect(p.prReviews.value).toEqual([{ id: 1, state: "DISMISSED" }]);
+  });
+
+  it("a ForgeNotImplementedError from dismissReview does not set `error`", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    ghDismissReview.mockRejectedValue(new ForgeNotImplementedError("gitlab", "dismissReview"));
+    await p.handleDismissReview(7);
+    expect(p.error.value).toBeNull();
+  });
+
+  it("forgeSupportsDismissReview is false on GitLab — no `dismissReview` method to hide behind a button that would silently no-op (verifier fix)", async () => {
+    gitRemoteInfo.mockResolvedValue({ url: "https://gitlab.com/o/r", host: "gitlab.com", provider: "gitlab", owner: "o", repo: "r" });
+    const p = usePrPanel(ref("/repo"));
+    await p.loadRemote();
+    await p.selectPr({ number: 1 } as any);
+    expect(p.forge.value.name).toBe("gitlab");
+    expect(p.forgeSupportsDismissReview.value).toBe(false);
+    // requestReviewers is real on GitLab — unaffected by this fix.
+    expect(p.forgeSupportsRequestReviewers.value).toBe(true);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-summary.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-summary.test.ts
new file mode 100644
index 00000000..f7e58b8e
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-summary.test.ts
@@ -0,0 +1,114 @@
+/**
+ * Task D1 (v3.6.0) — `usePrPanel` orchestration of the PR summary: opt-in,
+ * cache-first, regenerate bypasses the cache.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const ghPrDetail = vi.fn();
+const ghPrComments = vi.fn();
+const ghPrListReviews = vi.fn();
+const ghPrDiff = vi.fn();
+const gitExecMock = vi.fn();
+const rawPromptMock = vi.fn();
+const isAvailableRef = { value: true };
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: vi.fn(async () => ({ url: "", host: "github.com", owner: "o", repo: "r" })),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    ghPrListReviews: (...a: unknown[]) => ghPrListReviews(...a),
+    ghPrDiff: (...a: unknown[]) => ghPrDiff(...a),
+    gitExec: (...a: unknown[]) => gitExecMock(...a),
+  };
+});
+
+vi.mock("../useAIProvider", () => ({
+  useAIProvider: () => ({ isAvailable: isAvailableRef, rawPrompt: (...a: unknown[]) => rawPromptMock(...a) }),
+}));
+
+const settingsRef = ref<Record<string, unknown>>({ reviewAiSummary: false, reviewAiPreReview: false });
+vi.mock("../useSettings", () => ({ useSettings: () => ({ settings: settingsRef }) }));
+
+import { usePrPanel } from "../usePrPanel";
+import { usePrCache, detailKey, _resetPrCacheForTesting } from "../usePrCache";
+
+const RAW_DIFF = [
+  "diff --git a/a.ts b/a.ts",
+  "index 111..222 100644",
+  "--- a/a.ts",
+  "+++ b/a.ts",
+  "@@ -1,1 +1,1 @@",
+  "+x",
+].join("\n");
+
+function fakeDetail() {
+  return {
+    number: 1, title: "t", body: "", state: "open", author: "a", branch: "feat", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 1, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha: "sha1",
+  };
+}
+
+describe("usePrPanel — PR summary orchestration (D1)", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    settingsRef.value = { reviewAiSummary: false, reviewAiPreReview: false };
+    isAvailableRef.value = true;
+    ghPrDetail.mockReset().mockResolvedValue(fakeDetail());
+    ghPrComments.mockReset().mockResolvedValue([]);
+    ghPrListReviews.mockReset().mockResolvedValue([]);
+    ghPrDiff.mockReset().mockResolvedValue(RAW_DIFF);
+    gitExecMock.mockReset().mockResolvedValue({ stdout: "fix: bug", stderr: "", exitCode: 0 });
+    rawPromptMock.mockReset().mockResolvedValue("What: x. Why: y. Affected areas: a.ts.");
+  });
+
+  it("disabled: no call, prSummary stays empty", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await new Promise((r) => setTimeout(r, 5));
+    expect(rawPromptMock).not.toHaveBeenCalled();
+    expect(p.prSummary.value).toBe("");
+  });
+
+  it("enabled + cache hit: no call, instant paint", async () => {
+    settingsRef.value.reviewAiSummary = true;
+    usePrCache().setSummary(`${detailKey("/repo", 1)}@sha1`, "cached summary");
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await new Promise((r) => setTimeout(r, 5));
+    expect(rawPromptMock).not.toHaveBeenCalled();
+    expect(p.prSummary.value).toBe("cached summary");
+  });
+
+  it("enabled + miss: generates and writes through to the cache", async () => {
+    settingsRef.value.reviewAiSummary = true;
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await new Promise((r) => setTimeout(r, 10));
+    expect(rawPromptMock).toHaveBeenCalledTimes(1);
+    expect(p.prSummary.value).toContain("What: x.");
+    expect(usePrCache().getSummary(`${detailKey("/repo", 1)}@sha1`)).toContain("What: x.");
+  });
+
+  it("regenerateSummary bypasses the cache and rewrites it", async () => {
+    settingsRef.value.reviewAiSummary = true;
+    usePrCache().setSummary(`${detailKey("/repo", 1)}@sha1`, "stale summary");
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await new Promise((r) => setTimeout(r, 5));
+    expect(p.prSummary.value).toBe("stale summary");
+    expect(rawPromptMock).not.toHaveBeenCalled();
+
+    await p.regenerateSummary();
+    expect(rawPromptMock).toHaveBeenCalledTimes(1);
+    expect(p.prSummary.value).toContain("What: x.");
+    expect(usePrCache().getSummary(`${detailKey("/repo", 1)}@sha1`)).toContain("What: x.");
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPanel-viewed.test.ts b/apps/desktop/src/composables/__tests__/usePrPanel-viewed.test.ts
new file mode 100644
index 00000000..93e39c95
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPanel-viewed.test.ts
@@ -0,0 +1,88 @@
+/**
+ * Task B2 (v3.6.0) — `usePrPanel` wiring for client-side viewed-file state:
+ * seeding from the SWR cache on `selectPr`, toggling + persisting, forwarding
+ * to `submitReview`, and resetting on a re-push (headSha change).
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const ghPrDetail = vi.fn();
+const ghPrComments = vi.fn();
+const ghPrListReviews = vi.fn();
+const ghPrSubmitReview = vi.fn();
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: vi.fn(async () => ({ url: "", host: "github.com", owner: "o", repo: "r" })),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    ghPrListReviews: (...a: unknown[]) => ghPrListReviews(...a),
+    ghPrSubmitReview: (...a: unknown[]) => ghPrSubmitReview(...a),
+  };
+});
+
+import { usePrPanel } from "../usePrPanel";
+import { usePrCache, detailKey, _resetPrCacheForTesting } from "../usePrCache";
+
+function fakeDetail(headSha: string) {
+  return {
+    number: 1, title: "t", body: "", state: "open", author: "a", branch: "b", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 0, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha,
+  };
+}
+
+describe("usePrPanel — viewed-file state (B2)", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    _resetPrCacheForTesting();
+    ghPrDetail.mockReset().mockResolvedValue(fakeDetail("sha1"));
+    ghPrComments.mockReset().mockResolvedValue([]);
+    ghPrListReviews.mockReset().mockResolvedValue([]);
+    ghPrSubmitReview.mockReset().mockResolvedValue({});
+  });
+
+  it("selecting a PR seeds viewedPaths from the cache at the current headSha", async () => {
+    usePrCache().setViewed(detailKey("/repo", 1), "sha1", ["a.ts"]);
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    expect([...p.viewedPaths.value]).toEqual(["a.ts"]);
+  });
+
+  it("toggleViewed updates the count and persists to the cache", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    p.toggleViewed("a.ts");
+    expect(p.viewedCount.value).toBe(1);
+    expect(usePrCache().getViewed(detailKey("/repo", 1))?.paths).toEqual(["a.ts"]);
+  });
+
+  it("handleSubmitReview forwards viewedFiles to the forge", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    p.toggleViewed("a.ts");
+    await p.handleSubmitReview({ event: "COMMENT", body: "", comments: [] });
+    expect(ghPrSubmitReview).toHaveBeenCalledWith(
+      "/repo", 1, expect.objectContaining({ viewedFiles: ["a.ts"] }),
+    );
+  });
+
+  it("changing prDetail.headSha (re-push) resets viewed on next toggle", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    p.toggleViewed("a.ts");
+    expect(p.viewedCount.value).toBe(1);
+
+    // Simulate a re-push landing (revalidation picks up a new head SHA).
+    ghPrDetail.mockResolvedValue(fakeDetail("sha2"));
+    await p.revalidateOpenDetail();
+    expect(p.viewedCount.value).toBe(0); // stale-headSha entry reads as empty
+
+    p.toggleViewed("b.ts");
+    expect([...p.viewedPaths.value]).toEqual(["b.ts"]);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrPreReview.test.ts b/apps/desktop/src/composables/__tests__/usePrPreReview.test.ts
new file mode 100644
index 00000000..9e14a9b6
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrPreReview.test.ts
@@ -0,0 +1,185 @@
+/**
+ * Task C1 (v3.6.0) — local multi-hop pre-review engine.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { GitDiff, BlameLine } from "../../utils/backend";
+
+const rawPromptMock = vi.fn();
+const isAvailableRef = { value: true };
+const getGitBlameMock = vi.fn();
+
+vi.mock("../useAIProvider", () => ({
+  useAIProvider: () => ({
+    isAvailable: isAvailableRef,
+    rawPrompt: (...a: unknown[]) => rawPromptMock(...a),
+  }),
+}));
+
+vi.mock("../../utils/backend", () => ({
+  getGitBlame: (...a: unknown[]) => getGitBlameMock(...a),
+}));
+
+import {
+  usePrPreReview,
+  parseFindings,
+  computeImportedByCount,
+  importSourcesForFile,
+  summarizeBlameForFile,
+  buildUserPrompt,
+} from "../usePrPreReview";
+
+function diffFile(path: string, lines: { type: "add" | "delete" | "context"; content: string; newLineNo?: number; oldLineNo?: number }[]): GitDiff {
+  return {
+    path,
+    hunks: [{ header: "@@ -1,1 +1,1 @@", oldStart: 1, oldCount: 1, newStart: 1, newCount: 1, lines }],
+  };
+}
+
+function blameLine(overrides: Partial<BlameLine> = {}): BlameLine {
+  return {
+    hash: "abc1234", hashFull: "abc1234full", finalLine: 1, origLine: 1,
+    author: "alice", authorDate: "2026-01-01", summary: "fix bug", content: "code",
+    ...overrides,
+  };
+}
+
+describe("parseFindings", () => {
+  it("recovers a JSON array from a ```json fence", () => {
+    const raw = "```json\n[{\"line\": 3, \"title\": \"t\", \"severity\": \"risk\", \"confidence\": 80, \"detail\": \"d\"}]\n```";
+    const findings = parseFindings(raw, "a.ts");
+    expect(findings).toHaveLength(1);
+    expect(findings[0]).toMatchObject({ path: "a.ts", line: 3, severity: "risk", confidence: 80, title: "t", detail: "d" });
+    expect(findings[0].id).toBeTruthy();
+  });
+
+  it("recovers a JSON array embedded in surrounding prose", () => {
+    const raw = 'Here is my review:\n[{"line": 1, "title": "x"}]\nThanks!';
+    expect(parseFindings(raw, "a.ts")).toHaveLength(1);
+  });
+
+  it("clamps confidence to 0-100", () => {
+    const raw = '[{"line": 1, "title": "x", "confidence": 500}, {"line": 2, "title": "y", "confidence": -20}]';
+    const findings = parseFindings(raw, "a.ts");
+    expect(findings[0].confidence).toBe(100);
+    expect(findings[1].confidence).toBe(0);
+  });
+
+  it("coerces an unrecognized severity to 'suggestion'", () => {
+    const raw = '[{"line": 1, "title": "x", "severity": "catastrophic"}]';
+    expect(parseFindings(raw, "a.ts")[0].severity).toBe("suggestion");
+  });
+
+  it("drops entries missing line or title", () => {
+    const raw = '[{"title": "no line"}, {"line": 1}, {"line": 2, "title": "ok"}]';
+    const findings = parseFindings(raw, "a.ts");
+    expect(findings).toHaveLength(1);
+    expect(findings[0].title).toBe("ok");
+  });
+
+  it("assigns a stable id for the same path+line+title", () => {
+    const raw = '[{"line": 5, "title": "same"}]';
+    const a = parseFindings(raw, "a.ts")[0].id;
+    const b = parseFindings(raw, "a.ts")[0].id;
+    expect(a).toBe(b);
+  });
+
+  it("returns [] for malformed JSON", () => {
+    expect(parseFindings("not json at all", "a.ts")).toEqual([]);
+  });
+
+  it("returns [] when the top-level value isn't an array", () => {
+    expect(parseFindings('{"line": 1, "title": "x"}', "a.ts")).toEqual([]);
+  });
+});
+
+describe("dependency hop", () => {
+  it("importSourcesForFile extracts specifiers from added/context lines, ignoring deletes", () => {
+    const file = diffFile("a.ts", [
+      { type: "add", content: "import { b } from './b';", newLineNo: 1 },
+      { type: "delete", content: "import { old } from './old';", oldLineNo: 1 },
+    ]);
+    expect(importSourcesForFile(file)).toEqual(["./b"]);
+  });
+
+  it("computeImportedByCount counts diff files that import the target file", () => {
+    const a = diffFile("a.ts", [{ type: "add", content: "import { b } from './b';", newLineNo: 1 }]);
+    const b = diffFile("b.ts", [{ type: "context", content: "export const b = 1;" }]);
+    const c = diffFile("c.ts", [{ type: "add", content: "import { b } from './b';", newLineNo: 1 }]);
+    expect(computeImportedByCount(b, [a, c])).toBe(2);
+    expect(computeImportedByCount(a, [b, c])).toBe(0);
+  });
+
+  it("computeImportedByCount ignores bare package specifiers", () => {
+    const a = diffFile("a.ts", [{ type: "add", content: "import react from 'react';", newLineNo: 1 }]);
+    const react = diffFile("react.ts", []);
+    expect(computeImportedByCount(react, [a])).toBe(0);
+  });
+});
+
+describe("history hop", () => {
+  it("summarizeBlameForFile matches blame entries to the file's added lines", () => {
+    const file = diffFile("a.ts", [{ type: "add", content: "x", newLineNo: 5 }]);
+    const blame = [blameLine({ finalLine: 5, author: "bob", summary: "add x" }), blameLine({ finalLine: 99 })];
+    expect(summarizeBlameForFile(blame, file)).toEqual(["bob: add x"]);
+  });
+
+  it("dedupes identical author+summary pairs", () => {
+    const file = diffFile("a.ts", [
+      { type: "add", content: "x", newLineNo: 5 },
+      { type: "add", content: "y", newLineNo: 6 },
+    ]);
+    const blame = [blameLine({ finalLine: 5 }), blameLine({ finalLine: 6 })];
+    expect(summarizeBlameForFile(blame, file)).toEqual(["alice: fix bug"]);
+  });
+});
+
+describe("buildUserPrompt", () => {
+  it("includes the imported-by-N-diff-files signal", () => {
+    const file = diffFile("b.ts", [{ type: "add", content: "export const b = 1;", newLineNo: 1 }]);
+    const prompt = buildUserPrompt(file, 2, [], 6000);
+    expect(prompt).toContain("Imported by 2 other file(s) in this diff.");
+  });
+});
+
+describe("usePrPreReview.analyzeFile", () => {
+  beforeEach(() => {
+    rawPromptMock.mockReset();
+    getGitBlameMock.mockReset().mockResolvedValue([]);
+    isAvailableRef.value = true;
+  });
+
+  it("returns findings parsed from the AI response", async () => {
+    rawPromptMock.mockResolvedValue('[{"line": 2, "title": "missing null check", "severity": "risk", "confidence": 70}]');
+    const { analyzeFile } = usePrPreReview();
+    const file = diffFile("a.ts", [{ type: "add", content: "x.y()", newLineNo: 2 }]);
+    const findings = await analyzeFile(file, { cwd: "/repo", otherDiffFiles: [] });
+    expect(findings).toHaveLength(1);
+    expect(findings[0].title).toBe("missing null check");
+  });
+
+  it("returns [] gracefully when the model returns junk", async () => {
+    rawPromptMock.mockResolvedValue("I refuse to answer in JSON.");
+    const { analyzeFile } = usePrPreReview();
+    const file = diffFile("a.ts", [{ type: "add", content: "x", newLineNo: 1 }]);
+    expect(await analyzeFile(file, { cwd: "/repo", otherDiffFiles: [] })).toEqual([]);
+  });
+
+  it("returns [] when the AI provider is unavailable, without calling rawPrompt", async () => {
+    isAvailableRef.value = false;
+    const { analyzeFile } = usePrPreReview();
+    const file = diffFile("a.ts", [{ type: "add", content: "x", newLineNo: 1 }]);
+    expect(await analyzeFile(file, { cwd: "/repo", otherDiffFiles: [] })).toEqual([]);
+    expect(rawPromptMock).not.toHaveBeenCalled();
+  });
+
+  it("calls getGitBlame for the file and includes its summary in the prompt", async () => {
+    getGitBlameMock.mockResolvedValue([blameLine({ finalLine: 2, author: "carol", summary: "initial impl" })]);
+    rawPromptMock.mockResolvedValue("[]");
+    const { analyzeFile } = usePrPreReview();
+    const file = diffFile("a.ts", [{ type: "add", content: "x", newLineNo: 2 }]);
+    await analyzeFile(file, { cwd: "/repo", otherDiffFiles: [] });
+    expect(getGitBlameMock).toHaveBeenCalledWith("/repo", "a.ts");
+    const [, userPrompt] = rawPromptMock.mock.calls[0];
+    expect(userPrompt).toContain("carol: initial impl");
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrReviewKeymap.test.ts b/apps/desktop/src/composables/__tests__/usePrReviewKeymap.test.ts
new file mode 100644
index 00000000..82837e96
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrReviewKeymap.test.ts
@@ -0,0 +1,70 @@
+import { describe, it, expect } from "vitest";
+import { resolvePrReviewShortcut, isEditableTarget } from "../usePrReviewKeymap";
+
+function kd(key: string, opts: Partial<KeyboardEventInit> = {}): KeyboardEvent {
+  return new KeyboardEvent("keydown", { key, ...opts });
+}
+
+describe("resolvePrReviewShortcut", () => {
+  const focused = { focused: true };
+
+  it("maps each plain letter to its action", () => {
+    expect(resolvePrReviewShortcut(kd("j"), focused)).toBe("next-hunk");
+    expect(resolvePrReviewShortcut(kd("k"), focused)).toBe("prev-hunk");
+    expect(resolvePrReviewShortcut(kd("v"), focused)).toBe("toggle-viewed");
+    expect(resolvePrReviewShortcut(kd("t"), focused)).toBe("filter-files");
+    expect(resolvePrReviewShortcut(kd("c"), focused)).toBe("comment-hunk");
+    expect(resolvePrReviewShortcut(kd("?"), focused)).toBe("help");
+    expect(resolvePrReviewShortcut(kd("n"), focused)).toBe("next-finding");
+    expect(resolvePrReviewShortcut(kd("p"), focused)).toBe("prev-finding");
+  });
+
+  it("maps the Shift variants to file/hide-viewed actions", () => {
+    expect(resolvePrReviewShortcut(kd("J"), focused)).toBe("next-file");
+    expect(resolvePrReviewShortcut(kd("K"), focused)).toBe("prev-file");
+    expect(resolvePrReviewShortcut(kd("V"), focused)).toBe("toggle-hide-viewed");
+  });
+
+  it("maps ⌘Enter and Ctrl+Enter to submit-review", () => {
+    expect(resolvePrReviewShortcut(kd("Enter", { metaKey: true }), focused)).toBe("submit-review");
+    expect(resolvePrReviewShortcut(kd("Enter", { ctrlKey: true }), focused)).toBe("submit-review");
+  });
+
+  it("returns null when unfocused, regardless of key", () => {
+    expect(resolvePrReviewShortcut(kd("j"), { focused: false })).toBeNull();
+    expect(resolvePrReviewShortcut(kd("Enter", { metaKey: true }), { focused: false })).toBeNull();
+  });
+
+  it("returns null for unmapped keys", () => {
+    expect(resolvePrReviewShortcut(kd("x"), focused)).toBeNull();
+    expect(resolvePrReviewShortcut(kd("Escape"), focused)).toBeNull();
+    expect(resolvePrReviewShortcut(kd("l", { metaKey: true, shiftKey: true }), focused)).toBeNull();
+  });
+
+  it("treats an unrelated modifier as noise, not a shortcut", () => {
+    expect(resolvePrReviewShortcut(kd("j", { ctrlKey: true }), focused)).toBeNull();
+    expect(resolvePrReviewShortcut(kd("v", { altKey: true }), focused)).toBeNull();
+    expect(resolvePrReviewShortcut(kd("j", { metaKey: true }), focused)).toBeNull();
+  });
+});
+
+describe("isEditableTarget", () => {
+  it("is true for input/textarea/select", () => {
+    expect(isEditableTarget(document.createElement("input"))).toBe(true);
+    expect(isEditableTarget(document.createElement("textarea"))).toBe(true);
+    expect(isEditableTarget(document.createElement("select"))).toBe(true);
+  });
+
+  it("is true for a contenteditable element", () => {
+    const div = document.createElement("div");
+    div.setAttribute("contenteditable", "true");
+    document.body.appendChild(div);
+    expect(isEditableTarget(div)).toBe(true);
+    div.remove();
+  });
+
+  it("is false for a plain div/null", () => {
+    expect(isEditableTarget(document.createElement("div"))).toBe(false);
+    expect(isEditableTarget(null)).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrReviewNav.test.ts b/apps/desktop/src/composables/__tests__/usePrReviewNav.test.ts
new file mode 100644
index 00000000..630179bd
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrReviewNav.test.ts
@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref, computed, nextTick } from "vue";
+import { usePrReviewNav, type DiffRowLike } from "../usePrReviewNav";
+import type { GitDiff } from "../../utils/backend";
+import type { ReviewFinding } from "../usePrPreReview";
+
+function file(path: string, hunkCount: number): GitDiff {
+  return {
+    path,
+    hunks: Array.from({ length: hunkCount }, (_, i) => ({
+      header: `@@ hunk ${i} @@`, oldStart: 1, oldCount: 1, newStart: 1, newCount: 1, lines: [],
+    })),
+  };
+}
+
+function finding(overrides: Partial<ReviewFinding> = {}): ReviewFinding {
+  return { id: "1", path: "a.ts", line: 1, side: "RIGHT", severity: "suggestion", confidence: 80, title: "t", detail: "", ...overrides };
+}
+
+describe("usePrReviewNav", () => {
+  const scrollToHunk = vi.fn();
+  const scrollToLine = vi.fn();
+  const openComposeAtHunk = vi.fn();
+  const onHelp = vi.fn();
+  const onToggleViewed = vi.fn();
+  const onSubmitReview = vi.fn();
+
+  beforeEach(() => {
+    scrollToHunk.mockReset();
+    scrollToLine.mockReset();
+    openComposeAtHunk.mockReset();
+    onHelp.mockReset();
+    onToggleViewed.mockReset();
+    onSubmitReview.mockReset();
+  });
+
+  function setup(files: GitDiff[], selectedPath: string | null, findings: ReviewFinding[] = [], rows: DiffRowLike[] = []) {
+    const prDiffFiles = ref(files);
+    const selectedDiffFile = ref<string | null>(selectedPath);
+    // Mirrors `PrDetailView`'s real `selectedDiff` — a computed derived from
+    // `selectedDiffFile`, so switching files reactively updates the hunk
+    // count `goToHunk`'s boundary-crossing reads (not a manually-set ref).
+    const selectedDiff = computed<GitDiff | null>(
+      () => prDiffFiles.value.find((f) => f.path === selectedDiffFile.value) ?? null,
+    );
+    const diffHandle = ref({ scrollToHunk, scrollToLine, openComposeAtHunk, rows });
+    const hideViewed = ref(false);
+    const submittingReview = ref(false);
+    const findingsRef = ref(findings);
+    const nav = usePrReviewNav({
+      prDiffFiles, selectedDiffFile, selectedDiff, diffHandle, onHelp, onToggleViewed, hideViewed,
+      onSubmitReview, submittingReview, findings: findingsRef,
+    });
+    return { nav, prDiffFiles, selectedDiffFile, selectedDiff, hideViewed, submittingReview, findingsRef };
+  }
+
+  it("next-hunk advances the cursor within the file and scrolls to it", () => {
+    const { nav } = setup([file("a.ts", 3)], "a.ts");
+    nav.dispatch("next-hunk");
+    expect(nav.currentHunkIdx.value).toBe(1);
+    expect(scrollToHunk).toHaveBeenCalledWith(1);
+  });
+
+  it("prev-hunk at the first hunk crosses into the previous file's last hunk", async () => {
+    const { nav, selectedDiffFile } = setup([file("a.ts", 2), file("b.ts", 3)], "b.ts");
+    nav.dispatch("prev-hunk");
+    await nextTick();
+    expect(selectedDiffFile.value).toBe("a.ts");
+    await nextTick();
+    expect(nav.currentHunkIdx.value).toBe(1); // last hunk of a.ts (0-indexed, count 2)
+    expect(scrollToHunk).toHaveBeenCalledWith(1);
+  });
+
+  it("next-file (⇧J) wraps around and resets the hunk cursor", () => {
+    const { nav, selectedDiffFile } = setup([file("a.ts", 1), file("b.ts", 1)], "b.ts");
+    nav.currentHunkIdx.value = 5;
+    nav.dispatch("next-file");
+    expect(selectedDiffFile.value).toBe("a.ts");
+    expect(nav.currentHunkIdx.value).toBe(0);
+  });
+
+  it("comment-hunk opens the compose box at the current hunk", () => {
+    const { nav } = setup([file("a.ts", 2)], "a.ts");
+    nav.dispatch("comment-hunk");
+    expect(openComposeAtHunk).toHaveBeenCalledWith(0);
+  });
+
+  it("help calls the onHelp callback", () => {
+    const { nav } = setup([file("a.ts", 1)], "a.ts");
+    nav.dispatch("help");
+    expect(onHelp).toHaveBeenCalledTimes(1);
+  });
+
+  it("toggle-viewed (V) calls onToggleViewed with the selected file's path", () => {
+    const { nav } = setup([file("a.ts", 1)], "a.ts");
+    nav.dispatch("toggle-viewed");
+    expect(onToggleViewed).toHaveBeenCalledWith("a.ts");
+  });
+
+  it("toggle-viewed (V) is a no-op with no file selected", () => {
+    const { nav } = setup([file("a.ts", 1)], null);
+    nav.dispatch("toggle-viewed");
+    expect(onToggleViewed).not.toHaveBeenCalled();
+  });
+
+  it("toggle-hide-viewed (⇧V) flips the hideViewed ref", () => {
+    const { nav, hideViewed } = setup([file("a.ts", 1)], "a.ts");
+    nav.dispatch("toggle-hide-viewed");
+    expect(hideViewed.value).toBe(true);
+    nav.dispatch("toggle-hide-viewed");
+    expect(hideViewed.value).toBe(false);
+  });
+
+  it("submit-review (⌘Enter) opens the review modal", () => {
+    const { nav } = setup([file("a.ts", 1)], "a.ts");
+    nav.dispatch("submit-review");
+    expect(onSubmitReview).toHaveBeenCalledTimes(1);
+  });
+
+  it("submit-review is a no-op while a submit is already in flight", () => {
+    const { nav, submittingReview } = setup([file("a.ts", 1)], "a.ts");
+    submittingReview.value = true;
+    nav.dispatch("submit-review");
+    expect(onSubmitReview).not.toHaveBeenCalled();
+  });
+
+  it("next-finding (N) with no findings is a safe no-op", () => {
+    const { nav } = setup([file("a.ts", 1)], "a.ts");
+    expect(() => nav.dispatch("next-finding")).not.toThrow();
+    expect(scrollToHunk).not.toHaveBeenCalled();
+    expect(openComposeAtHunk).not.toHaveBeenCalled();
+  });
+
+  it("next-finding (N) lands on the first finding, switching file and scrolling to its row", async () => {
+    const findings = [finding({ id: "1", path: "b.ts", line: 5 })];
+    const rows = [{ kind: "line", dl: { type: "add", newLineNo: 5 } }];
+    const { nav, selectedDiffFile } = setup([file("a.ts", 1), file("b.ts", 1)], "a.ts", findings, rows);
+    nav.dispatch("next-finding");
+    await nextTick();
+    expect(selectedDiffFile.value).toBe("b.ts");
+    expect(scrollToLine).toHaveBeenCalledWith(0);
+    expect(nav.currentFindingIdx.value).toBe(0);
+  });
+
+  it("next-finding (N) then prev-finding (P) returns to the same finding", async () => {
+    const findings = [finding({ id: "1", line: 1 }), finding({ id: "2", line: 2 })];
+    const { nav } = setup([file("a.ts", 1)], "a.ts", findings, []);
+    nav.dispatch("next-finding");
+    await nextTick();
+    expect(nav.currentFindingIdx.value).toBe(0);
+    nav.dispatch("next-finding");
+    await nextTick();
+    expect(nav.currentFindingIdx.value).toBe(1);
+    nav.dispatch("prev-finding");
+    await nextTick();
+    expect(nav.currentFindingIdx.value).toBe(0);
+  });
+
+  it("next-finding (N) wraps around past the last finding", async () => {
+    const findings = [finding({ id: "1" }), finding({ id: "2" })];
+    const { nav } = setup([file("a.ts", 1)], "a.ts", findings, []);
+    nav.dispatch("next-finding");
+    nav.dispatch("next-finding");
+    await nextTick();
+    nav.dispatch("next-finding");
+    await nextTick();
+    expect(nav.currentFindingIdx.value).toBe(0);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrReviewQueue.test.ts b/apps/desktop/src/composables/__tests__/usePrReviewQueue.test.ts
new file mode 100644
index 00000000..3f7bea85
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrReviewQueue.test.ts
@@ -0,0 +1,109 @@
+/**
+ * Task C3 (v3.6.0) — bounded, cancellable, visibility-gated queue.
+ */
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { usePrReviewQueue } from "../usePrReviewQueue";
+import type { GitDiff } from "../../utils/backend";
+import type { ReviewFinding } from "../usePrPreReview";
+
+function file(path: string): GitDiff {
+  return { path, hunks: [] };
+}
+
+function finding(path: string): ReviewFinding {
+  return { id: path, path, line: 1, side: "RIGHT", severity: "nit", confidence: 50, title: path, detail: "" };
+}
+
+function setHidden(hidden: boolean) {
+  Object.defineProperty(document, "hidden", { value: hidden, configurable: true });
+}
+
+describe("usePrReviewQueue", () => {
+  afterEach(() => {
+    setHidden(false);
+  });
+
+  it("processes files sequentially — analyzeOne never overlaps", async () => {
+    const order: string[] = [];
+    let concurrent = 0;
+    let maxConcurrent = 0;
+    const analyzeOne = vi.fn(async (f: GitDiff) => {
+      concurrent++;
+      maxConcurrent = Math.max(maxConcurrent, concurrent);
+      order.push(f.path);
+      await new Promise((r) => setTimeout(r, 1));
+      concurrent--;
+      return [finding(f.path)];
+    });
+    const { run } = usePrReviewQueue();
+    const controller = new AbortController();
+    const found: ReviewFinding[] = [];
+    await run([file("a.ts"), file("b.ts"), file("c.ts")], analyzeOne, {
+      onFinding: (f) => found.push(f),
+      signal: controller.signal,
+    });
+    expect(order).toEqual(["a.ts", "b.ts", "c.ts"]);
+    expect(maxConcurrent).toBe(1);
+    expect(found.map((f) => f.path)).toEqual(["a.ts", "b.ts", "c.ts"]);
+  });
+
+  it("aborts mid-run when the signal fires", async () => {
+    const controller = new AbortController();
+    const analyzeOne = vi.fn(async (f: GitDiff) => {
+      if (f.path === "b.ts") controller.abort();
+      return [finding(f.path)];
+    });
+    const { run, done } = usePrReviewQueue();
+    const found: ReviewFinding[] = [];
+    await run([file("a.ts"), file("b.ts"), file("c.ts")], analyzeOne, {
+      onFinding: (f) => found.push(f),
+      signal: controller.signal,
+    });
+    expect(analyzeOne).toHaveBeenCalledTimes(2); // a.ts, b.ts — never reaches c.ts
+    expect(found.map((f) => f.path)).toEqual(["a.ts"]); // b.ts's finding is discarded post-abort
+    expect(done.value).toBe(1);
+  });
+
+  it("pauses while document.hidden and resumes once resume() is called", async () => {
+    setHidden(true);
+    const analyzeOne = vi.fn(async (f: GitDiff) => [finding(f.path)]);
+    const { run, resume, done } = usePrReviewQueue();
+    const controller = new AbortController();
+    const found: ReviewFinding[] = [];
+
+    const runPromise = run([file("a.ts")], analyzeOne, {
+      onFinding: (f) => found.push(f),
+      signal: controller.signal,
+    });
+
+    // Give the microtask queue a beat — the run loop should be blocked on
+    // `document.hidden`, not have called analyzeOne yet.
+    await new Promise((r) => setTimeout(r, 5));
+    expect(analyzeOne).not.toHaveBeenCalled();
+    expect(done.value).toBe(0);
+
+    setHidden(false);
+    resume();
+    await runPromise;
+
+    expect(analyzeOne).toHaveBeenCalledTimes(1);
+    expect(found.map((f) => f.path)).toEqual(["a.ts"]);
+  });
+
+  it("an abort while paused on document.hidden unblocks the wait", async () => {
+    setHidden(true);
+    const analyzeOne = vi.fn(async (f: GitDiff) => [finding(f.path)]);
+    const { run } = usePrReviewQueue();
+    const controller = new AbortController();
+
+    const runPromise = run([file("a.ts")], analyzeOne, {
+      onFinding: () => {},
+      signal: controller.signal,
+    });
+    await new Promise((r) => setTimeout(r, 5));
+    controller.abort();
+    await runPromise; // must resolve, not hang forever
+
+    expect(analyzeOne).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/usePrSummary.test.ts b/apps/desktop/src/composables/__tests__/usePrSummary.test.ts
new file mode 100644
index 00000000..5c16b64d
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/usePrSummary.test.ts
@@ -0,0 +1,84 @@
+/**
+ * Task D1 (v3.6.0) — AI PR summary generator.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const rawPromptMock = vi.fn();
+const isAvailableRef = { value: true };
+const gitExecMock = vi.fn();
+
+vi.mock("../useAIProvider", () => ({
+  useAIProvider: () => ({ isAvailable: isAvailableRef, rawPrompt: (...a: unknown[]) => rawPromptMock(...a) }),
+}));
+vi.mock("../../utils/backend", () => ({ gitExec: (...a: unknown[]) => gitExecMock(...a) }));
+
+import { usePrSummary, buildSummaryPrompt } from "../usePrSummary";
+
+describe("buildSummaryPrompt", () => {
+  it("includes commit titles and a per-file +/- count", () => {
+    const prompt = buildSummaryPrompt(
+      [{ path: "a.ts", raw: "+line1\n+line2\n-old" }],
+      ["fix: handle null case"],
+    );
+    expect(prompt).toContain("fix: handle null case");
+    expect(prompt).toContain("a.ts (+2/-1)");
+  });
+
+  it("notes missing commit titles gracefully", () => {
+    const prompt = buildSummaryPrompt([{ path: "a.ts", raw: "" }], []);
+    expect(prompt).toContain("(no commit titles available)");
+  });
+});
+
+describe("usePrSummary.generate", () => {
+  beforeEach(() => {
+    rawPromptMock.mockReset();
+    gitExecMock.mockReset();
+    isAvailableRef.value = true;
+  });
+
+  it("returns the model's text, including fetched commit titles", async () => {
+    gitExecMock.mockResolvedValue({ stdout: "fix: bug\nfeat: thing", stderr: "", exitCode: 0 });
+    rawPromptMock.mockResolvedValue("What: does X.\nWhy: because Y.\nAffected areas: src/.");
+    const { generate } = usePrSummary();
+    const summary = await generate({ cwd: "/repo", base: "main", head: "feat", files: [{ path: "a.ts", raw: "+x" }] });
+    expect(summary).toContain("What: does X.");
+    expect(gitExecMock).toHaveBeenCalledWith("/repo", ["log", "--format=%s", "main..feat"]);
+    const [, userPrompt] = rawPromptMock.mock.calls[0];
+    expect(userPrompt).toContain("fix: bug");
+  });
+
+  it("falls back to origin/<base>..origin/<head> when the plain range fails", async () => {
+    gitExecMock
+      .mockResolvedValueOnce({ stdout: "", stderr: "unknown revision", exitCode: 128 })
+      .mockResolvedValueOnce({ stdout: "chore: setup", stderr: "", exitCode: 0 });
+    rawPromptMock.mockResolvedValue("summary");
+    const { generate } = usePrSummary();
+    await generate({ cwd: "/repo", base: "main", head: "feat", files: [{ path: "a.ts", raw: "+x" }] });
+    expect(gitExecMock).toHaveBeenCalledTimes(2);
+    expect(gitExecMock).toHaveBeenLastCalledWith("/repo", ["log", "--format=%s", "origin/main..origin/feat"]);
+  });
+
+  it("generates from the file index alone when no commit titles are found", async () => {
+    gitExecMock.mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+    rawPromptMock.mockResolvedValue("summary");
+    const { generate } = usePrSummary();
+    const summary = await generate({ cwd: "/repo", base: "main", head: "feat", files: [{ path: "a.ts", raw: "+x" }] });
+    expect(summary).toBe("summary");
+  });
+
+  it("returns '' when the AI provider is unavailable", async () => {
+    isAvailableRef.value = false;
+    const { generate } = usePrSummary();
+    const summary = await generate({ cwd: "/repo", base: "main", head: "feat", files: [{ path: "a.ts", raw: "+x" }] });
+    expect(summary).toBe("");
+    expect(rawPromptMock).not.toHaveBeenCalled();
+  });
+
+  it("returns '' for an empty diff (no files)", async () => {
+    const { generate } = usePrSummary();
+    const summary = await generate({ cwd: "/repo", base: "main", head: "feat", files: [] });
+    expect(summary).toBe("");
+    expect(rawPromptMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useReviewIntelligence.test.ts b/apps/desktop/src/composables/__tests__/useReviewIntelligence.test.ts
new file mode 100644
index 00000000..7b19e5f4
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useReviewIntelligence.test.ts
@@ -0,0 +1,192 @@
+/**
+ * Task E2 (v3.6.0) — unified AI + static Intelligence orchestrator.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+
+const ghPrDetail = vi.fn();
+const ghPrComments = vi.fn();
+const ghPrListReviews = vi.fn();
+const ghPrDiff = vi.fn();
+const ghCheckAnnotations = vi.fn();
+
+vi.mock("@/utils/backend", async () => {
+  const actual = await vi.importActual<typeof import("@/utils/backend")>("@/utils/backend");
+  return {
+    ...actual,
+    gitRemoteInfo: vi.fn(async () => ({ url: "", host: "github.com", owner: "o", repo: "r" })),
+    ghForkInfo: vi.fn(async () => ({ isFork: false, origin: "", parent: "" })),
+    ghPrDetail: (...a: unknown[]) => ghPrDetail(...a),
+    ghPrComments: (...a: unknown[]) => ghPrComments(...a),
+    ghPrListReviews: (...a: unknown[]) => ghPrListReviews(...a),
+    ghPrDiff: (...a: unknown[]) => ghPrDiff(...a),
+    ghCheckAnnotations: (...a: unknown[]) => ghCheckAnnotations(...a),
+  };
+});
+
+const settingsRef = ref<Record<string, unknown>>({
+  reviewAiPreReview: true, reviewAiConfidenceThreshold: 0, reviewAiMaxFindings: 15, reviewAiSummary: false,
+});
+vi.mock("../useSettings", () => ({ useSettings: () => ({ settings: settingsRef }) }));
+vi.mock("../useAIProvider", () => ({
+  useAIProvider: () => ({
+    isAvailable: ref(true),
+    rawPrompt: vi.fn(async () => '[{"line": 1, "title": "ai finding", "severity": "risk", "confidence": 90}]'),
+  }),
+}));
+
+import { usePrPanel } from "../usePrPanel";
+import { computeStaticFlags, useReviewIntelligence } from "../useReviewIntelligence";
+import { usePrCache, detailKey } from "../usePrCache";
+import { normalizeFindingClass } from "../usePrFindingFilter";
+import type { ReviewFinding } from "../usePrPreReview";
+import type { GitDiff } from "../../utils/backend";
+
+const RAW_DIFF = [
+  "diff --git a/a.ts b/a.ts",
+  "index 111..222 100644",
+  "--- a/a.ts",
+  "+++ b/a.ts",
+  "@@ -1,1 +1,1 @@",
+  " context",
+  "+x",
+].join("\n");
+
+function fakeDetail() {
+  return {
+    number: 1, title: "t", body: "", state: "open", author: "a", branch: "b", base: "main",
+    draft: false, createdAt: "", updatedAt: "", mergedAt: "", url: "", additions: 0, deletions: 0,
+    changedFiles: 1, comments: 0, reviewComments: 0, labels: [], reviewers: [], mergeable: "MERGEABLE",
+    checksStatus: "success", canMerge: true, headSha: "sha1",
+  };
+}
+
+describe("useReviewIntelligence — merged stream (via usePrPanel)", () => {
+  beforeEach(() => {
+    settingsRef.value = { reviewAiPreReview: true, reviewAiConfidenceThreshold: 0, reviewAiMaxFindings: 15, reviewAiSummary: false };
+    ghPrDetail.mockReset().mockResolvedValue(fakeDetail());
+    ghPrComments.mockReset().mockResolvedValue([]);
+    ghPrListReviews.mockReset().mockResolvedValue([]);
+    ghPrDiff.mockReset().mockResolvedValue(RAW_DIFF);
+    ghCheckAnnotations.mockReset().mockResolvedValue([
+      { checkName: "lint", path: "a.ts", startLine: 1, endLine: 1, level: "warning", title: "ci finding", message: "" },
+    ]);
+  });
+
+  it("mergedAnnotationsByFile contains CI + AI entries, distinct by source", async () => {
+    const p = usePrPanel(ref("/repo"));
+    await p.selectPr({ number: 1 } as any);
+    await p.loadAnnotations();
+    await new Promise((r) => setTimeout(r, 10));
+
+    const merged = p.mergedAnnotationsByFile.value["a.ts"] ?? [];
+    expect(merged.map((a) => a.source).sort()).toEqual(["ai", "ci"]);
+  });
+});
+
+describe("useReviewIntelligence — dismissal memory applies on a cache hit too (verifier fix)", () => {
+  beforeEach(() => {
+    settingsRef.value = { reviewAiPreReview: true, reviewAiConfidenceThreshold: 0, reviewAiMaxFindings: 15, reviewAiSummary: false };
+    localStorage.clear();
+  });
+
+  it("a dismissed finding class stays hidden after restart even though its findings are already cached at the current headSha", async () => {
+    const cwd = "/repo";
+    const prNumber = 42;
+    const headSha = "sha-cached";
+    const key = `${detailKey(cwd, prNumber)}@${headSha}`;
+
+    const dismissedFinding: ReviewFinding = {
+      id: "f1", path: "a.ts", line: 1, side: "RIGHT", severity: "nit", confidence: 80,
+      title: "unused variable x", detail: "",
+    };
+    const keptFinding: ReviewFinding = {
+      id: "f2", path: "b.ts", line: 2, side: "RIGHT", severity: "risk", confidence: 90,
+      title: "possible null deref", detail: "",
+    };
+
+    // Simulate a PREVIOUS session: findings were cached at this headSha, and
+    // the user dismissed one of them (persisted to the repo-scoped dismissal
+    // set) — both survive an app restart via localStorage.
+    const cache = usePrCache();
+    cache.setFindings(key, [dismissedFinding, keptFinding]);
+    cache.addDismissed(cwd, normalizeFindingClass(dismissedFinding));
+
+    // Fresh composable instance — as if the app just restarted and the PR
+    // detail is reopened at the same (unchanged) headSha, so `maybeRunPreReview`
+    // takes the cache-HIT path rather than re-running the pipeline.
+    const intel = useReviewIntelligence({
+      cwd: ref(cwd),
+      selectedPr: ref({ number: prNumber } as any),
+      prDetail: ref({ headSha } as any),
+      detailTab: ref("diff"),
+      loadDiff: vi.fn(async () => {}),
+      diffIndex: ref([]),
+      annotationsByFile: ref({}),
+    });
+
+    await intel.maybeRunPreReview();
+
+    const ids = intel.preReviewFindings.value.map((f) => f.id);
+    expect(ids).not.toContain("f1");
+    expect(ids).toContain("f2");
+  });
+});
+
+describe("computeStaticFlags — regression parity with the pre-E2 aiFlags thresholds", () => {
+  const t = (key: string, ...args: Array<string | number>) => {
+    let s = key;
+    args.forEach((a, i) => { s = s.replace(`{${i}}`, String(a)); });
+    return s;
+  };
+
+  function bigFile(): GitDiff {
+    const lines = Array.from({ length: 250 }, (_, i) => ({ type: "add" as const, content: `x${i}`, newLineNo: i + 1 }));
+    return { path: "big.ts", hunks: [{ header: "@@ @@", oldStart: 1, oldCount: 0, newStart: 1, newCount: 250, lines }] };
+  }
+
+  it("flags a file with > 200 changed lines (warning)", () => {
+    const flags = computeStaticFlags([bigFile()], t as any);
+    expect(flags.some((f) => f.severity === "warning" && f.title.includes("pr.intel.flagBigFile"))).toBe(true);
+  });
+
+  it("flags a removed export as failure, anchored to the deleted line", () => {
+    const diff: GitDiff = {
+      path: "a.ts",
+      hunks: [{
+        header: "@@ @@", oldStart: 1, oldCount: 1, newStart: 1, newCount: 0,
+        lines: [{ type: "delete", content: "export function foo() {}", oldLineNo: 5 }],
+      }],
+    };
+    const flags = computeStaticFlags([diff], t as any);
+    const flag = flags.find((f) => f.title.includes("flagExportRemoved"));
+    expect(flag).toBeDefined();
+    expect(flag?.severity).toBe("failure");
+    expect(flag?.side).toBe("LEFT");
+    expect(flag?.line).toBe(5);
+  });
+
+  it("flags a config file change (notice)", () => {
+    const diff: GitDiff = { path: "config.yaml", hunks: [{ header: "@@ @@", oldStart: 1, oldCount: 0, newStart: 1, newCount: 1, lines: [{ type: "add", content: "x", newLineNo: 1 }] }] };
+    const flags = computeStaticFlags([diff], t as any);
+    expect(flags.some((f) => f.title.includes("flagConfigChange") && f.severity === "notice")).toBe(true);
+  });
+
+  it("flags a migration file (warning)", () => {
+    const diff: GitDiff = { path: "db/migrate/001.sql", hunks: [{ header: "@@ @@", oldStart: 1, oldCount: 0, newStart: 1, newCount: 1, lines: [{ type: "add", content: "x", newLineNo: 1 }] }] };
+    const flags = computeStaticFlags([diff], t as any);
+    expect(flags.some((f) => f.title.includes("flagDbMigration") && f.severity === "warning")).toBe(true);
+  });
+
+  it("flags a hunk with > 100 lines only once per file", () => {
+    const lines = Array.from({ length: 150 }, (_, i) => ({ type: "add" as const, content: `x${i}`, newLineNo: i + 1 }));
+    const diff: GitDiff = { path: "a.ts", hunks: [{ header: "@@ @@", oldStart: 1, oldCount: 0, newStart: 1, newCount: 150, lines }] };
+    const flags = computeStaticFlags([diff], t as any);
+    expect(flags.filter((f) => f.title.includes("flagBigHunk"))).toHaveLength(1);
+  });
+
+  it("returns [] for a small, unremarkable diff", () => {
+    const diff: GitDiff = { path: "a.ts", hunks: [{ header: "@@ @@", oldStart: 1, oldCount: 1, newStart: 1, newCount: 1, lines: [{ type: "context", content: "x", oldLineNo: 1, newLineNo: 1 }] }] };
+    expect(computeStaticFlags([diff], t as any)).toEqual([]);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useSettings-reviewAi.test.ts b/apps/desktop/src/composables/__tests__/useSettings-reviewAi.test.ts
new file mode 100644
index 00000000..fd35911b
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useSettings-reviewAi.test.ts
@@ -0,0 +1,47 @@
+/**
+ * Task E3 (v3.6.0) — Review AI settings: defaults + persistence round-trip.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { defaultAppSettings, loadSettings, saveSettings } from "../useSettings";
+
+describe("Review AI settings (E3)", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("defaults match the spec: pre-review/summary off, threshold 60, cap 15", () => {
+    expect(defaultAppSettings.reviewAiPreReview).toBe(false);
+    expect(defaultAppSettings.reviewAiConfidenceThreshold).toBe(60);
+    expect(defaultAppSettings.reviewAiMaxFindings).toBe(15);
+    expect(defaultAppSettings.reviewAiSummary).toBe(false);
+  });
+
+  it("round-trips through save/load", () => {
+    saveSettings({
+      ...defaultAppSettings,
+      reviewAiPreReview: true,
+      reviewAiConfidenceThreshold: 80,
+      reviewAiMaxFindings: 5,
+      reviewAiSummary: true,
+    });
+    const loaded = loadSettings();
+    expect(loaded.reviewAiPreReview).toBe(true);
+    expect(loaded.reviewAiConfidenceThreshold).toBe(80);
+    expect(loaded.reviewAiMaxFindings).toBe(5);
+    expect(loaded.reviewAiSummary).toBe(true);
+  });
+
+  it("loadSettings backfills defaults for a stored payload missing the new fields", () => {
+    const legacy = { ...defaultAppSettings } as Record<string, unknown>;
+    delete legacy.reviewAiPreReview;
+    delete legacy.reviewAiConfidenceThreshold;
+    delete legacy.reviewAiMaxFindings;
+    delete legacy.reviewAiSummary;
+    localStorage.setItem("gitwand-settings", JSON.stringify(legacy));
+    const loaded = loadSettings();
+    expect(loaded.reviewAiPreReview).toBe(false);
+    expect(loaded.reviewAiConfidenceThreshold).toBe(60);
+    expect(loaded.reviewAiMaxFindings).toBe(15);
+    expect(loaded.reviewAiSummary).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useVirtualRows.test.ts b/apps/desktop/src/composables/__tests__/useVirtualRows.test.ts
new file mode 100644
index 00000000..bc5f859f
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useVirtualRows.test.ts
@@ -0,0 +1,78 @@
+/**
+ * Task A2 (v3.6.0) — `useVirtualRows` wiring test. jsdom has no real layout,
+ * so this asserts the virtualizer is constructed/reconfigured correctly, not
+ * pixel output.
+ */
+import { describe, it, expect, vi } from "vitest";
+import { ref } from "vue";
+
+const setOptions = vi.fn();
+const getVirtualItems = vi.fn(() => [{ index: 0, key: 0, start: 0, size: 40 }]);
+const getTotalSize = vi.fn(() => 400);
+const measureElement = vi.fn();
+
+function makeVirtualizerInstance(options: Record<string, unknown>) {
+  return {
+    options,
+    setOptions: (next: Record<string, unknown>) => {
+      Object.assign(options, next);
+      setOptions(next);
+    },
+    getVirtualItems,
+    getTotalSize,
+    measureElement,
+  };
+}
+
+vi.mock("@tanstack/vue-virtual", () => ({
+  useVirtualizer: vi.fn((options: Record<string, unknown>) => ref(makeVirtualizerInstance(options))),
+}));
+
+import { useVirtualizer } from "@tanstack/vue-virtual";
+import { useVirtualRows } from "../useVirtualRows";
+
+describe("useVirtualRows", () => {
+  it("constructs the virtualizer with the given count/estimateSize/overscan", () => {
+    const count = ref(10);
+    const estimateSize = (i: number) => 40 + i;
+    useVirtualRows({ count, getScrollElement: () => null, estimateSize, overscan: 4 });
+
+    expect(useVirtualizer).toHaveBeenCalledWith(
+      expect.objectContaining({ count: 10, estimateSize, overscan: 4 }),
+    );
+  });
+
+  it("defaults overscan to 8 when not provided", () => {
+    const count = ref(1);
+    useVirtualRows({ count, getScrollElement: () => null, estimateSize: () => 40 });
+    expect(useVirtualizer).toHaveBeenCalledWith(expect.objectContaining({ overscan: 8 }));
+  });
+
+  it("recomputes the virtualizer's count when the reactive count changes", async () => {
+    const count = ref(3);
+    useVirtualRows({ count, getScrollElement: () => null, estimateSize: () => 40 });
+    setOptions.mockClear();
+
+    count.value = 7;
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(setOptions).toHaveBeenCalledWith(expect.objectContaining({ count: 7 }));
+  });
+
+  it("exposes virtualItems/totalSize/measure delegating to the virtualizer", () => {
+    const count = ref(1);
+    const { virtualItems, totalSize, measure } = useVirtualRows({
+      count, getScrollElement: () => null, estimateSize: () => 40,
+    });
+
+    expect(totalSize.value).toBe(400);
+    expect(virtualItems.value).toEqual([{ index: 0, key: 0, start: 0, size: 40 }]);
+
+    const el = {} as Element;
+    measure(el);
+    expect(measureElement).toHaveBeenCalledWith(el);
+    measure(null);
+    expect(measureElement).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/desktop/src/composables/forge/GitHubProvider.ts b/apps/desktop/src/composables/forge/GitHubProvider.ts
index 979700ce..caac4df6 100644
--- a/apps/desktop/src/composables/forge/GitHubProvider.ts
+++ b/apps/desktop/src/composables/forge/GitHubProvider.ts
@@ -32,6 +32,8 @@ import {
   ghPrDeleteComment,
   ghPrListReviews,
   ghPrSubmitReview,
+  ghDismissReview,
+  ghRequestReviewers,
   ghPrConflictPreview,
   ghPrHotspots,
   ghPrFileHistory,
@@ -177,6 +179,14 @@ export class GitHubProvider implements ForgeProvider {
     return ghPrSubmitReview(cwd, prNumber, opts);
   }
 
+  dismissReview(cwd: string, prNumber: number, reviewId: number, message?: string): Promise<void> {
+    return ghDismissReview(cwd, prNumber, reviewId, message);
+  }
+
+  requestReviewers(cwd: string, prNumber: number, logins: string[]): Promise<void> {
+    return ghRequestReviewers(cwd, prNumber, logins);
+  }
+
   // ── Intelligence ──────────────────────────────────────────────────────────
 
   getConflictPreview(cwd: string, prNumber: number): Promise<PrConflictPreview> {
diff --git a/apps/desktop/src/composables/forge/GitLabProvider.ts b/apps/desktop/src/composables/forge/GitLabProvider.ts
index d5858ae0..b9a073c1 100644
--- a/apps/desktop/src/composables/forge/GitLabProvider.ts
+++ b/apps/desktop/src/composables/forge/GitLabProvider.ts
@@ -45,6 +45,8 @@ import {
   glBranches,
   glMrFiles,
   glListIssues,
+  glRequestReviewers,
+  glMrDiffRefs,
 } from "../../utils/backend";
 import { ghPrConflictPreview, ghPrHotspots } from "../../utils/backend";
 
@@ -69,6 +71,12 @@ import type {
   Issue,
   Account,
 } from "./types";
+import type { PendingReviewComment } from "../../utils/backend";
+
+/** Note-body markers `submitReview` writes so `listReviews` can later
+ *  derive a verdict from plain MR notes (GitLab has no review resource). */
+const CHANGES_REQUESTED_MARKER = "**Changes requested:**";
+const COMMENT_REVIEW_MARKER = "**Review:**";
 
 export class GitLabProvider implements ForgeProvider {
   readonly name: ForgeName = "gitlab";
@@ -76,6 +84,16 @@ export class GitLabProvider implements ForgeProvider {
   /** Active account — auth managed by `glab` CLI; stored for API completeness. */
   private _account: Account | null = null;
 
+  /**
+   * Last MR iid resolved via `getPR` (F1, v3.6.0). `getFileHistory`'s
+   * `ForgeProvider` signature carries no `prNumber` (it's shared across all
+   * forges, and GitHub's implementation is repo-wide), but a real GitLab
+   * heuristic needs *some* MR to fetch notes from — the most recently
+   * opened one is the only sane default. Stays `null` (empty file history,
+   * matching the old placeholder) until a PR detail has actually loaded.
+   */
+  private _lastIid: number | null = null;
+
   setAccount(account: Account | null): void {
     this._account = account;
   }
@@ -122,6 +140,7 @@ export class GitLabProvider implements ForgeProvider {
   // ── MR detail ──────────────────────────────────────────────────────────────
 
   getPR(cwd: string, number: number): Promise<PullRequestDetail> {
+    this._lastIid = number;
     return glGetMr(cwd, number);
   }
 
@@ -181,12 +200,14 @@ export class GitLabProvider implements ForgeProvider {
   ): Promise<PrReviewComment> {
     // Use diff-line Discussions API when position info is available.
     if (params.path && params.line != null) {
+      const refs = await glMrDiffRefs(cwd, prNumber);
+      const side = params.side ?? "RIGHT";
       return glMrCreateDiscussion(cwd, prNumber, params.body, {
-        baseSha: (params as any).base_sha ?? "",
-        startSha: (params as any).start_sha ?? (params as any).base_sha ?? "",
-        headSha: (params as any).head_sha ?? "",
-        oldLine: null,
-        newLine: params.line ?? null,
+        baseSha: refs.baseSha,
+        startSha: refs.startSha,
+        headSha: refs.headSha,
+        oldLine: side === "LEFT" ? params.line : null,
+        newLine: side === "RIGHT" ? params.line : null,
         path: params.path,
       });
     }
@@ -207,21 +228,72 @@ export class GitLabProvider implements ForgeProvider {
     return glMrDeleteNote(cwd, prNumber, commentId);
   }
 
-  // ── Reviews (approvals) ────────────────────────────────────────────────────
+  // ── Reviews (approvals + note-derived verdicts, F1 v3.6.0) ─────────────────
   //
   // GitLab uses an approval model rather than GitHub's review states:
   //   APPROVE          → POST /merge_requests/:iid/approve
-  //   REQUEST_CHANGES  → no equivalent; create a blocking note
-  //   COMMENT          → create a general note
+  //   REQUEST_CHANGES  → no equivalent; create a note prefixed with a marker
+  //   COMMENT          → create a note prefixed with a (different) marker
+  // `listReviews` scans notes for those markers to surface
+  // CHANGES_REQUESTED/COMMENTED verdicts alongside real approvals — GitLab
+  // has no structured "review" resource to query directly.
+
+  /** Post each pending inline comment as a real Discussions-API discussion,
+   *  fetching diff refs once and reusing them (F1). No-op when empty. */
+  private async postBatchComments(
+    cwd: string,
+    prNumber: number,
+    comments?: PendingReviewComment[],
+  ): Promise<void> {
+    if (!comments?.length) return;
+    const refs = await glMrDiffRefs(cwd, prNumber);
+    for (const c of comments) {
+      await glMrCreateDiscussion(cwd, prNumber, c.body, {
+        baseSha: refs.baseSha,
+        startSha: refs.startSha,
+        headSha: refs.headSha,
+        oldLine: c.side === "LEFT" ? c.line : null,
+        newLine: c.side === "RIGHT" ? c.line : null,
+        path: c.path,
+      });
+    }
+  }
 
-  listReviews(cwd: string, prNumber: number): Promise<PrReview[]> {
-    return glListReviews(cwd, prNumber);
+  async listReviews(cwd: string, prNumber: number): Promise<PrReview[]> {
+    const [approvals, notes] = await Promise.all([
+      glListReviews(cwd, prNumber),
+      glMrNotes(cwd, prNumber).catch(() => [] as PrReviewComment[]),
+    ]);
+    const derived: PrReview[] = [];
+    for (const note of notes) {
+      let state: "CHANGES_REQUESTED" | "COMMENTED" | null = null;
+      let marker = "";
+      if (note.body.startsWith(CHANGES_REQUESTED_MARKER)) {
+        state = "CHANGES_REQUESTED";
+        marker = CHANGES_REQUESTED_MARKER;
+      } else if (note.body.startsWith(COMMENT_REVIEW_MARKER)) {
+        state = "COMMENTED";
+        marker = COMMENT_REVIEW_MARKER;
+      }
+      if (!state) continue;
+      derived.push({
+        id: note.id,
+        state,
+        body: note.body.slice(marker.length).trim(),
+        user: { login: note.author, avatar_url: "" },
+        submitted_at: note.created_at,
+        html_url: "",
+      });
+    }
+    return [...approvals, ...derived];
   }
 
   async submitReview(cwd: string, prNumber: number, opts: SubmitReviewOptions): Promise<PrReview> {
     if (opts.event === "APPROVE") {
       await glApproveMr(cwd, prNumber);
-      // glab mr approve doesn't return a review object — synthesize one.
+      await this.postBatchComments(cwd, prNumber, opts.comments);
+      // glab mr approve doesn't return a review object — synthesize a
+      // representative one reflecting what actually happened.
       return {
         id: 0,
         state: "APPROVED",
@@ -232,11 +304,14 @@ export class GitLabProvider implements ForgeProvider {
       };
     }
 
-    // REQUEST_CHANGES or COMMENT: create a note with the body.
+    // REQUEST_CHANGES or COMMENT: create a marked note with the body (so
+    // `listReviews` can later derive the verdict from it), then batch-post
+    // any staged inline comments as real Discussions-API discussions.
+    const marker = opts.event === "REQUEST_CHANGES" ? CHANGES_REQUESTED_MARKER : COMMENT_REVIEW_MARKER;
     if (opts.body) {
-      const prefix = opts.event === "REQUEST_CHANGES" ? "**Changes requested:**\n\n" : "";
-      await glMrCreateNote(cwd, prNumber, prefix + opts.body);
+      await glMrCreateNote(cwd, prNumber, `${marker}\n\n${opts.body}`);
     }
+    await this.postBatchComments(cwd, prNumber, opts.comments);
 
     return {
       id: 0,
@@ -248,6 +323,17 @@ export class GitLabProvider implements ForgeProvider {
     };
   }
 
+  // `dismissReview` is intentionally omitted — GitLab has no direct "dismiss
+  // a review" equivalent (approvals/notes aren't a dismissible review object
+  // like GitHub's). Leaving the method undefined (rather than defined-but-
+  // throwing) is what lets `usePrPanel`'s `forgeSupportsDismissReview`
+  // capability check (`typeof forge.dismissReview === "function"`) hide the
+  // action instead of showing a button that's a silent no-op (B4, v3.6.0).
+
+  requestReviewers(cwd: string, prNumber: number, logins: string[]): Promise<void> {
+    return glRequestReviewers(cwd, prNumber, logins);
+  }
+
   // ── Intelligence (forge-agnostique depuis v2.14) ───────────────────────────
 
   async getConflictPreview(cwd: string, prNumber: number): Promise<PrConflictPreview> {
@@ -263,18 +349,34 @@ export class GitLabProvider implements ForgeProvider {
   }
 
   async getFileHistory(cwd: string, paths: string[]): Promise<Record<string, PrFileHistory>> {
-    // GitLab implementation: aggregate all MR notes mentioning each file path.
-    // This is a heuristic — a note body containing the path string counts as
-    // a review touch. Not as precise as GitHub's structured review comment API,
-    // but sufficient for the "N reviews on this file" chip in the diff view.
+    // Real heuristic (F1, v3.6.0): fetch the current MR's notes once, count
+    // how many mention each path (anchored discussion note, or a general
+    // note whose body happens to reference the path), collect reviewers,
+    // and keep the most recent as `lastComment`.
     //
-    // We fetch all notes (already available from listComments) without re-fetching
-    // per MR — so we pass prNumber=0 as a placeholder; glMrNotes requires iid.
-    // For file history we scan notes across the current PR only.
+    // `ForgeProvider.getFileHistory` carries no `prNumber` (shared across
+    // forges; GitHub's own implementation is repo-wide) — GitLab has no
+    // cheap repo-wide "notes across all MRs" query, so this uses the most
+    // recently opened MR (`_lastIid`, set by `getPR`) as the scope. Empty
+    // history (matching the old placeholder) until a PR detail has loaded.
     const result: Record<string, PrFileHistory> = {};
     for (const path of paths) {
       result[path] = { reviewCommentCount: 0, reviewers: [], lastComment: null };
     }
+    if (this._lastIid == null) return result;
+
+    const notes = await glMrNotes(cwd, this._lastIid).catch(() => [] as PrReviewComment[]);
+    for (const path of paths) {
+      const matching = notes.filter((n) => n.path === path || n.body.includes(path));
+      if (!matching.length) continue;
+      const reviewers = [...new Set(matching.map((n) => n.author).filter(Boolean))];
+      const last = matching[matching.length - 1];
+      result[path] = {
+        reviewCommentCount: matching.length,
+        reviewers,
+        lastComment: { author: last.author, body: last.body, pr_number: String(this._lastIid) },
+      };
+    }
     return result;
   }
 }
diff --git a/apps/desktop/src/composables/forge/__tests__/AzureProvider.test.ts b/apps/desktop/src/composables/forge/__tests__/AzureProvider.test.ts
new file mode 100644
index 00000000..570a6e47
--- /dev/null
+++ b/apps/desktop/src/composables/forge/__tests__/AzureProvider.test.ts
@@ -0,0 +1,30 @@
+/**
+ * AzureProvider — F2 (v3.6.0): `updateComment`/`deleteComment` are honest
+ * unsupported errors (typed `ForgeNotImplementedError`), never a bare
+ * runtime throw, so the UI can hide the affordance instead of crashing.
+ */
+import { describe, it, expect } from "vitest";
+import { AzureProvider } from "../AzureProvider";
+import { ForgeNotImplementedError } from "../types";
+
+describe("AzureProvider — comment edit/delete capability (F2)", () => {
+  it("updateComment throws a typed ForgeNotImplementedError", () => {
+    const provider = new AzureProvider();
+    expect(() => provider.updateComment("/repo", 1, "new body")).toThrow(ForgeNotImplementedError);
+    try {
+      provider.updateComment("/repo", 1, "new body");
+    } catch (err: any) {
+      expect(err.name).toBe("ForgeNotImplementedError");
+    }
+  });
+
+  it("deleteComment throws a typed ForgeNotImplementedError", () => {
+    const provider = new AzureProvider();
+    expect(() => provider.deleteComment("/repo", 1)).toThrow(ForgeNotImplementedError);
+    try {
+      provider.deleteComment("/repo", 1);
+    } catch (err: any) {
+      expect(err.name).toBe("ForgeNotImplementedError");
+    }
+  });
+});
diff --git a/apps/desktop/src/composables/forge/__tests__/GitLabProvider.test.ts b/apps/desktop/src/composables/forge/__tests__/GitLabProvider.test.ts
new file mode 100644
index 00000000..db67c833
--- /dev/null
+++ b/apps/desktop/src/composables/forge/__tests__/GitLabProvider.test.ts
@@ -0,0 +1,143 @@
+/**
+ * GitLabProvider — B4 (v3.6.0): `dismissReview` has no direct GitLab
+ * equivalent, so the method is omitted entirely (left `undefined`) rather
+ * than defined-but-throwing — that's what lets `usePrPanel`'s
+ * `forgeSupportsDismissReview` capability check
+ * (`typeof forge.dismissReview === "function"`) correctly hide the action
+ * instead of showing a button that's a silent no-op (verifier fix, v3.6.0).
+ * `requestReviewers` is real.
+ * F1 (v3.6.0): real inline batch review, `listReviews`, type-clean
+ * `createComment`, and a real `getFileHistory` heuristic.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const glRequestReviewers = vi.fn();
+const glMrDiffRefs = vi.fn();
+const glMrCreateDiscussion = vi.fn();
+const glMrCreateNote = vi.fn();
+const glApproveMr = vi.fn();
+const glListReviews = vi.fn();
+const glMrNotes = vi.fn();
+const glGetMr = vi.fn();
+
+vi.mock("../../../utils/backend", () => ({
+  glRequestReviewers: (...a: unknown[]) => glRequestReviewers(...a),
+  glMrDiffRefs: (...a: unknown[]) => glMrDiffRefs(...a),
+  glMrCreateDiscussion: (...a: unknown[]) => glMrCreateDiscussion(...a),
+  glMrCreateNote: (...a: unknown[]) => glMrCreateNote(...a),
+  glApproveMr: (...a: unknown[]) => glApproveMr(...a),
+  glListReviews: (...a: unknown[]) => glListReviews(...a),
+  glMrNotes: (...a: unknown[]) => glMrNotes(...a),
+  glGetMr: (...a: unknown[]) => glGetMr(...a),
+}));
+
+import { GitLabProvider } from "../GitLabProvider";
+import type { ForgeProvider } from "../types";
+
+const REFS = { baseSha: "base1", startSha: "start1", headSha: "head1" };
+
+function note(overrides: Partial<Record<string, unknown>> = {}) {
+  return { id: 1, body: "hi", author: "alice", created_at: "2026-01-01", updated_at: "", path: "", line: null, original_line: null, side: "RIGHT", start_line: null, start_side: null, in_reply_to_id: null, diff_hunk: "", url: "", ...overrides };
+}
+
+describe("GitLabProvider — review admin (B4)", () => {
+  beforeEach(() => {
+    glRequestReviewers.mockReset().mockResolvedValue(undefined);
+  });
+
+  it("does not implement dismissReview — GitLab has no direct equivalent", () => {
+    const provider: ForgeProvider = new GitLabProvider();
+    expect(provider.dismissReview).toBeUndefined();
+  });
+
+  it("requestReviewers delegates to glRequestReviewers", async () => {
+    const provider = new GitLabProvider();
+    await provider.requestReviewers("/repo", 5, ["alice", "bob"]);
+    expect(glRequestReviewers).toHaveBeenCalledWith("/repo", 5, ["alice", "bob"]);
+  });
+});
+
+describe("GitLabProvider — real review completion (F1)", () => {
+  beforeEach(() => {
+    glMrDiffRefs.mockReset().mockResolvedValue(REFS);
+    glMrCreateDiscussion.mockReset().mockResolvedValue({ id: 1 });
+    glMrCreateNote.mockReset().mockResolvedValue({ id: 2 });
+    glApproveMr.mockReset().mockResolvedValue(undefined);
+    glListReviews.mockReset().mockResolvedValue([]);
+    glMrNotes.mockReset().mockResolvedValue([]);
+    glGetMr.mockReset().mockResolvedValue({});
+  });
+
+  it("createComment fetches diff refs and anchors on the RIGHT side by default", async () => {
+    const provider = new GitLabProvider();
+    await provider.createComment("/repo", 5, { body: "nit", path: "a.ts", line: 3 });
+    expect(glMrDiffRefs).toHaveBeenCalledWith("/repo", 5);
+    expect(glMrCreateDiscussion).toHaveBeenCalledWith("/repo", 5, "nit", {
+      baseSha: "base1", startSha: "start1", headSha: "head1", oldLine: null, newLine: 3, path: "a.ts",
+    });
+  });
+
+  it("createComment anchors on the LEFT side when side is LEFT", async () => {
+    const provider = new GitLabProvider();
+    await provider.createComment("/repo", 5, { body: "nit", path: "a.ts", line: 3, side: "LEFT" });
+    expect(glMrCreateDiscussion).toHaveBeenCalledWith("/repo", 5, "nit", expect.objectContaining({ oldLine: 3, newLine: null }));
+  });
+
+  it("submitReview with comments fetches refs once and posts each as a discussion", async () => {
+    const provider = new GitLabProvider();
+    await provider.submitReview("/repo", 5, {
+      event: "COMMENT",
+      body: "",
+      comments: [
+        { path: "a.ts", line: 1, side: "RIGHT", body: "c1" },
+        { path: "b.ts", line: 2, side: "LEFT", body: "c2" },
+      ],
+    });
+    expect(glMrDiffRefs).toHaveBeenCalledTimes(1);
+    expect(glMrCreateDiscussion).toHaveBeenCalledTimes(2);
+    expect(glMrCreateDiscussion).toHaveBeenCalledWith("/repo", 5, "c1", expect.objectContaining({ newLine: 1, oldLine: null }));
+    expect(glMrCreateDiscussion).toHaveBeenCalledWith("/repo", 5, "c2", expect.objectContaining({ newLine: null, oldLine: 2 }));
+  });
+
+  it("submitReview REQUEST_CHANGES writes a marked note listReviews can derive from", async () => {
+    const provider = new GitLabProvider();
+    const review = await provider.submitReview("/repo", 5, { event: "REQUEST_CHANGES", body: "please fix", comments: [] });
+    expect(review.state).toBe("CHANGES_REQUESTED");
+    expect(glMrCreateNote).toHaveBeenCalledWith("/repo", 5, expect.stringContaining("please fix"));
+  });
+
+  it("listReviews merges approvals with a note-derived CHANGES_REQUESTED verdict", async () => {
+    glListReviews.mockResolvedValue([{ id: 0, state: "APPROVED", body: "", user: { login: "bob", avatar_url: "" }, submitted_at: "", html_url: "" }]);
+    glMrNotes.mockResolvedValue([note({ id: 10, body: "**Changes requested:**\n\nfix it", author: "carol" })]);
+    const provider = new GitLabProvider();
+    const reviews = await provider.listReviews("/repo", 5);
+    expect(reviews).toHaveLength(2);
+    expect(reviews.some((r) => r.state === "APPROVED")).toBe(true);
+    const derived = reviews.find((r) => r.state === "CHANGES_REQUESTED");
+    expect(derived?.body).toBe("fix it");
+    expect(derived?.user.login).toBe("carol");
+  });
+
+  it("getFileHistory counts notes per path after a PR has been loaded via getPR", async () => {
+    glGetMr.mockResolvedValue({ number: 5 });
+    glMrNotes.mockResolvedValue([
+      note({ id: 1, path: "a.ts", author: "alice", body: "note1" }),
+      note({ id: 2, path: "a.ts", author: "bob", body: "note2" }),
+      note({ id: 3, path: "b.ts", author: "carol", body: "note3" }),
+    ]);
+    const provider = new GitLabProvider();
+    await provider.getPR("/repo", 5); // sets _lastIid
+    const history = await provider.getFileHistory("/repo", ["a.ts", "b.ts", "c.ts"]);
+    expect(history["a.ts"].reviewCommentCount).toBe(2);
+    expect(history["a.ts"].reviewers.sort()).toEqual(["alice", "bob"]);
+    expect(history["b.ts"].reviewCommentCount).toBe(1);
+    expect(history["c.ts"].reviewCommentCount).toBe(0);
+  });
+
+  it("getFileHistory returns empty placeholders before any PR has loaded", async () => {
+    const provider = new GitLabProvider();
+    const history = await provider.getFileHistory("/repo", ["a.ts"]);
+    expect(history["a.ts"]).toEqual({ reviewCommentCount: 0, reviewers: [], lastComment: null });
+    expect(glMrNotes).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/desktop/src/composables/forge/types.ts b/apps/desktop/src/composables/forge/types.ts
index 9d491f57..2721fbb6 100644
--- a/apps/desktop/src/composables/forge/types.ts
+++ b/apps/desktop/src/composables/forge/types.ts
@@ -78,6 +78,13 @@ export interface SubmitReviewOptions {
   event: "APPROVE" | "REQUEST_CHANGES" | "COMMENT";
   body?: string;
   comments?: PendingReviewComment[];
+  /**
+   * Client-tracked viewed-file paths at submit time (B2, v3.6.0). Optional
+   * forge transport — GitHub has no native "viewed" API, so the client
+   * (`usePrCache`'s per-PR viewed set) stays the source of truth regardless;
+   * providers may simply ignore this field.
+   */
+  viewedFiles?: string[];
 }
 
 // ─── Forge name discriminant ────────────────────────────────────────────────
@@ -195,6 +202,19 @@ export interface ForgeProvider {
 
   submitReview(cwd: string, prNumber: number, opts: SubmitReviewOptions): Promise<PrReview>;
 
+  /**
+   * Dismiss a submitted review (B4, v3.6.0). Optional — a provider that
+   * can't support it (GitLab has no direct equivalent; Bitbucket/Azure omit
+   * it) either doesn't implement the method or throws
+   * `ForgeNotImplementedError`; callers must treat both as "unsupported"
+   * and hide the action rather than surface an error banner.
+   */
+  dismissReview?(cwd: string, prNumber: number, reviewId: number, message?: string): Promise<void>;
+
+  /** Request reviewers on an existing PR/MR (B4, v3.6.0). Optional — same
+   *  unsupported-hides-the-action contract as `dismissReview`. */
+  requestReviewers?(cwd: string, prNumber: number, logins: string[]): Promise<void>;
+
   // ── Intelligence (forge-agnostique depuis v2.14) ───────────────────────────
   //
   // getConflictPreview et getHotspots s'appuient sur des données git locales
diff --git a/apps/desktop/src/composables/prAiLocale.ts b/apps/desktop/src/composables/prAiLocale.ts
new file mode 100644
index 00000000..68c53e81
--- /dev/null
+++ b/apps/desktop/src/composables/prAiLocale.ts
@@ -0,0 +1,21 @@
+/**
+ * prAiLocale.ts
+ *
+ * Maps a product `SupportedLocale` to the language name used in AI system
+ * prompts (pre-review findings, PR summary). Shared by `usePrPreReview.ts`
+ * and `usePrSummary.ts` so the two can't drift — previously each duplicated
+ * a `locale === "fr" ? "French" : "English"` check that silently produced
+ * English output for es/pt-BR/zh-CN users (verifier fix, v3.6.0).
+ */
+const AI_LANGUAGE_BY_LOCALE: Record<string, string> = {
+  en: "English",
+  fr: "French",
+  es: "Spanish",
+  "pt-BR": "Brazilian Portuguese",
+  "zh-CN": "Simplified Chinese",
+};
+
+/** Falls back to English for an unrecognized or missing locale. */
+export function localeToAiLanguage(locale: string | undefined): string {
+  return (locale && AI_LANGUAGE_BY_LOCALE[locale]) ?? "English";
+}
diff --git a/apps/desktop/src/composables/prAnnotations.ts b/apps/desktop/src/composables/prAnnotations.ts
new file mode 100644
index 00000000..841f2746
--- /dev/null
+++ b/apps/desktop/src/composables/prAnnotations.ts
@@ -0,0 +1,124 @@
+/**
+ * prAnnotations.ts
+ *
+ * Shared `LineAnnotation` model (E1, v3.6.0) — a forge-agnostic, source-
+ * agnostic line annotation used to merge CI check-run annotations, AI
+ * pre-review findings (C4), and static-flag heuristics (E2) into one
+ * overlay stream for `PrInlineDiff.vue`. Deliberately keeps an *open*
+ * severity scale (not the old 3-level `mapAnnotation` normalization) so AI
+ * findings can carry their own confidence/severity untouched.
+ *
+ * Pure module — no Vue, no composable state — testable in isolation.
+ */
+import type { CIAnnotation } from "../utils/backend";
+import type { ReviewFinding } from "./usePrPreReview";
+
+export type AnnotationSource = "ci" | "ai" | "static";
+export type LineSide = "LEFT" | "RIGHT";
+
+export interface LineAnnotation {
+  source: AnnotationSource;
+  path: string;
+  /** Anchor line (start of the range for multi-line annotations). */
+  line: number;
+  /** Which diff side the line number refers to. Defaults to RIGHT (new side)
+   *  at the call site — CI annotations and most AI findings are anchored on
+   *  the head commit. */
+  side: LineSide;
+  endLine?: number;
+  /** Open severity scale: "failure"|"warning"|"notice" (CI), "risk"|
+   *  "suggestion"|"nit" (AI/static), or any future source's own vocabulary. */
+  severity: string;
+  /** 0-100 — AI findings only. */
+  confidence?: number;
+  title: string;
+  message?: string;
+  /** CI source only — the check-run/job/report name. */
+  checkName?: string;
+  /** AI source only — a stable id for dismissal/navigation (C2/C4). */
+  id?: string;
+}
+
+/** Range annotations are expanded line-by-line; capped so a report spanning
+ *  a whole file doesn't flag hundreds of rows. */
+export const ANN_RANGE_CAP = 20;
+
+/** Map a v2.18 `CIAnnotation` (new-side only) onto the shared model. */
+export function fromCIAnnotation(a: CIAnnotation): LineAnnotation {
+  return {
+    source: "ci",
+    path: a.path,
+    line: a.startLine,
+    side: "RIGHT",
+    endLine: a.endLine,
+    severity: a.level,
+    title: a.title,
+    message: a.message,
+    checkName: a.checkName,
+  };
+}
+
+/** Map an AI pre-review finding (C1-C3) onto the shared model (C4). */
+export function fromFinding(f: ReviewFinding): LineAnnotation {
+  return {
+    source: "ai",
+    path: f.path,
+    line: f.line,
+    side: f.side,
+    severity: f.severity,
+    confidence: f.confidence,
+    title: f.title,
+    message: f.detail,
+    id: f.id,
+  };
+}
+
+/**
+ * Group annotations by `${side}:${line}` so LEFT and RIGHT annotations on
+ * the same line number never merge (old/new sides are independent). Range
+ * annotations are expanded line-by-line, capped at `cap` lines.
+ */
+export function annotationsByLine(
+  anns: LineAnnotation[],
+  cap: number = ANN_RANGE_CAP,
+): Map<string, LineAnnotation[]> {
+  const map = new Map<string, LineAnnotation[]>();
+  for (const a of anns) {
+    const end = Math.min(a.endLine ?? a.line, a.line + cap - 1);
+    for (let l = a.line; l <= end; l++) {
+      const key = `${a.side}:${l}`;
+      const list = map.get(key);
+      if (list) list.push(a);
+      else map.set(key, [a]);
+    }
+  }
+  return map;
+}
+
+/** Lower rank = more severe. Unknown severities sort last (still shown, just
+ *  never picked as "worst" over a recognized one). */
+const SEVERITY_RANK: Record<string, number> = {
+  failure: 0,
+  risk: 0,
+  warning: 1,
+  suggestion: 1,
+  notice: 2,
+  nit: 2,
+};
+
+/** The most severe annotation's severity string, for the gutter icon. Falls
+ *  back to the first annotation's own severity when none are recognized
+ *  (still deterministic, never throws on an unknown vocabulary). */
+export function worstSeverity(anns: LineAnnotation[]): string {
+  if (!anns.length) return "notice";
+  let best = anns[0];
+  let bestRank = SEVERITY_RANK[best.severity] ?? Infinity;
+  for (const a of anns.slice(1)) {
+    const rank = SEVERITY_RANK[a.severity] ?? Infinity;
+    if (rank < bestRank) {
+      best = a;
+      bestRank = rank;
+    }
+  }
+  return best.severity;
+}
diff --git a/apps/desktop/src/composables/usePrCache.ts b/apps/desktop/src/composables/usePrCache.ts
index c2d6f00b..a81024ee 100644
--- a/apps/desktop/src/composables/usePrCache.ts
+++ b/apps/desktop/src/composables/usePrCache.ts
@@ -17,7 +17,9 @@ import type {
   PrReviewComment,
   PrReview,
   RemoteInfo,
+  PendingReviewComment,
 } from "../utils/backend";
+import type { ReviewFinding } from "./usePrPreReview";
 
 export const PR_CACHE_STORAGE_KEY = "gitwand-pr-cache";
 const STORAGE_KEY = PR_CACHE_STORAGE_KEY;
@@ -36,9 +38,12 @@ export interface CachedList {
 
 export interface DetailBundle {
   detail: PullRequestDetail;
-  checks: CICheck[];
+  /** Optional (A3) — the hot path no longer fetches checks/issueComments up
+   *  front; they're written back once their tab's lazy loader fires. Read
+   *  with a `?? []` default so an older cached entry still parses. */
+  checks?: CICheck[];
   comments: PrReviewComment[];
-  issueComments: PrReviewComment[];
+  issueComments?: PrReviewComment[];
   reviews: PrReview[];
 }
 
@@ -51,14 +56,66 @@ export interface CachedRemote {
   ts: number;
 }
 
+/**
+ * Client-side per-PR viewed-file state (B2, v3.6.0), keyed by `detailKey`.
+ * `headSha` pins the state to a specific head commit — GitHub has no native
+ * "viewed" API, so the client is the source of truth, and a re-push (new
+ * `headSha`) invalidates the whole PR's viewed set at once (coarser than
+ * per-file blob-SHA invalidation, which is a noted follow-up).
+ */
+export interface ViewedState {
+  headSha: string;
+  paths: string[];
+  ts: number;
+}
+
+/** A pending (not-yet-submitted) review draft, keyed by `detailKey` (B3). */
+export interface DraftState {
+  comments: PendingReviewComment[];
+  ts: number;
+}
+
+/** Local dismissal memory for AI pre-review findings, keyed by `cwd` (C2).
+ *  `classes` are `normalizeFindingClass` values (see `usePrFindingFilter.ts`) —
+ *  dismissing a finding suppresses future occurrences of the same class,
+ *  below the confidence threshold or not. */
+export interface DismissedState {
+  classes: string[];
+  ts: number;
+}
+
+/** AI pre-review findings for a PR at a specific head SHA (C3), keyed
+ *  `${detailKey}@${headSha}` — a headSha change simply misses the cache
+ *  (no explicit invalidation needed; the stale key is pruned by age/LRU
+ *  like every other entry). */
+export interface FindingsState {
+  findings: ReviewFinding[];
+  ts: number;
+}
+
+/** AI PR summary text, keyed `${detailKey}@${headSha}` (D1) — same
+ *  headSha-miss-recomputes contract as `FindingsState`. */
+export interface SummaryState {
+  text: string;
+  ts: number;
+}
+
 interface PrCacheFile {
   lists: Record<string, CachedList>;
   details: Record<string, CachedDetail>;
   remotes: Record<string, CachedRemote>;
+  viewed: Record<string, ViewedState>;
+  drafts: Record<string, DraftState>;
+  dismissedFindings: Record<string, DismissedState>;
+  findings: Record<string, FindingsState>;
+  summaries: Record<string, SummaryState>;
 }
 
 function emptyFile(): PrCacheFile {
-  return { lists: {}, details: {}, remotes: {} };
+  return {
+    lists: {}, details: {}, remotes: {}, viewed: {}, drafts: {},
+    dismissedFindings: {}, findings: {}, summaries: {},
+  };
 }
 
 // Strictly-increasing write clock. Wall-clock `Date.now()` can return the same
@@ -97,11 +154,21 @@ function loadFromStorage(): PrCacheFile {
       lists: parsed.lists ?? {},
       details: parsed.details ?? {},
       remotes: parsed.remotes ?? {},
+      viewed: parsed.viewed ?? {},
+      drafts: parsed.drafts ?? {},
+      dismissedFindings: parsed.dismissedFindings ?? {},
+      findings: parsed.findings ?? {},
+      summaries: parsed.summaries ?? {},
     };
     const now = Date.now();
     pruneByAge(file.lists, now);
     pruneByAge(file.details, now);
     pruneByAge(file.remotes, now);
+    pruneByAge(file.viewed, now);
+    pruneByAge(file.drafts, now);
+    pruneByAge(file.dismissedFindings, now);
+    pruneByAge(file.findings, now);
+    pruneByAge(file.summaries, now);
     return file;
   } catch {
     return emptyFile();
@@ -112,6 +179,11 @@ function saveToStorage(file: PrCacheFile): void {
   evictLru(file.lists, MAX_LISTS);
   evictLru(file.details, MAX_DETAILS);
   evictLru(file.remotes, MAX_LISTS);
+  evictLru(file.viewed, MAX_DETAILS);
+  evictLru(file.drafts, MAX_DETAILS);
+  evictLru(file.dismissedFindings, MAX_LISTS);
+  evictLru(file.findings, MAX_DETAILS);
+  evictLru(file.summaries, MAX_DETAILS);
   try {
     localStorage.setItem(STORAGE_KEY, JSON.stringify(file));
   } catch (e) {
@@ -186,9 +258,98 @@ export function usePrCache() {
     saveToStorage(_file);
   }
 
+  // ── Viewed-file state (B2) ────────────────────────────────────────────────
+
+  function getViewed(key: string): { headSha: string; paths: string[] } | null {
+    const v = _file.viewed[key];
+    return v ? { headSha: v.headSha, paths: v.paths } : null;
+  }
+
+  function setViewed(key: string, headSha: string, paths: string[]): void {
+    _file.viewed[key] = { headSha, paths, ts: monoNow() };
+    saveToStorage(_file);
+  }
+
+  /**
+   * Toggle `path` in/out of the viewed set for `key`. If the stored state was
+   * recorded against a different `headSha` (a re-push happened), the whole
+   * set is cleared first — "re-push resets viewed" at PR granularity (the
+   * simplest honest behavior; per-file blob-SHA invalidation is a follow-up).
+   */
+  function toggleViewed(key: string, headSha: string, path: string): void {
+    const existing = _file.viewed[key];
+    const paths = existing && existing.headSha === headSha ? [...existing.paths] : [];
+    const idx = paths.indexOf(path);
+    if (idx === -1) paths.push(path);
+    else paths.splice(idx, 1);
+    _file.viewed[key] = { headSha, paths, ts: monoNow() };
+    saveToStorage(_file);
+  }
+
+  // ── Pending review draft (B3) ─────────────────────────────────────────────
+
+  function getDraft(key: string): PendingReviewComment[] | null {
+    return _file.drafts[key]?.comments ?? null;
+  }
+
+  function setDraft(key: string, comments: PendingReviewComment[]): void {
+    _file.drafts[key] = { comments, ts: monoNow() };
+    saveToStorage(_file);
+  }
+
+  function clearDraft(key: string): void {
+    delete _file.drafts[key];
+    saveToStorage(_file);
+  }
+
+  // ── AI finding dismissal memory (C2) ──────────────────────────────────────
+
+  function getDismissed(cwd: string): Set<string> {
+    return new Set(_file.dismissedFindings[cwd]?.classes ?? []);
+  }
+
+  function addDismissed(cwd: string, cls: string): void {
+    const existing = _file.dismissedFindings[cwd]?.classes ?? [];
+    if (existing.includes(cls)) {
+      // Still bump `ts` so an active repo's dismissal memory doesn't age out
+      // ahead of genuinely idle ones under LRU eviction.
+      _file.dismissedFindings[cwd] = { classes: existing, ts: monoNow() };
+    } else {
+      _file.dismissedFindings[cwd] = { classes: [...existing, cls], ts: monoNow() };
+    }
+    saveToStorage(_file);
+  }
+
+  // ── AI pre-review findings cache, by headSha (C3) ─────────────────────────
+
+  function getFindings(key: string): ReviewFinding[] | null {
+    return _file.findings[key]?.findings ?? null;
+  }
+
+  function setFindings(key: string, findings: ReviewFinding[]): void {
+    _file.findings[key] = { findings, ts: monoNow() };
+    saveToStorage(_file);
+  }
+
+  // ── AI PR summary cache, by headSha (D1) ──────────────────────────────────
+
+  function getSummary(key: string): string | null {
+    return _file.summaries[key]?.text ?? null;
+  }
+
+  function setSummary(key: string, text: string): void {
+    _file.summaries[key] = { text, ts: monoNow() };
+    saveToStorage(_file);
+  }
+
   return {
     getList, setList, invalidateLists,
     getDetail, setDetail, invalidateDetail,
     getRemote, setRemote,
+    getDismissed, addDismissed,
+    getFindings, setFindings,
+    getSummary, setSummary,
+    getViewed, setViewed, toggleViewed,
+    getDraft, setDraft, clearDraft,
   };
 }
diff --git a/apps/desktop/src/composables/usePrFindingFilter.ts b/apps/desktop/src/composables/usePrFindingFilter.ts
new file mode 100644
index 00000000..86fc2305
--- /dev/null
+++ b/apps/desktop/src/composables/usePrFindingFilter.ts
@@ -0,0 +1,42 @@
+/**
+ * usePrFindingFilter.ts
+ *
+ * Signal/noise controls for AI pre-review findings (C2, v3.6.0) — pure,
+ * no Vue state: confidence threshold, top-N cap by confidence, and local
+ * dismissal memory keyed by a normalized "finding class" so a dismissed
+ * finding stays hidden across recomputes and sessions, even if its exact
+ * line number shifts.
+ */
+import type { ReviewFinding } from "./usePrPreReview";
+
+/**
+ * Normalize a finding into a stable class: the file's directory + a
+ * digit-collapsed, lower-cased title. Two findings with the same title but
+ * a different line number, or a different digit in the title (e.g. "unused
+ * variable x2" vs "unused variable x7"), collapse to the same class.
+ */
+export function normalizeFindingClass(f: { path: string; title: string }): string {
+  const slash = f.path.lastIndexOf("/");
+  const dir = slash === -1 ? "" : f.path.slice(0, slash);
+  const title = f.title.toLowerCase().replace(/\d+/g, "#").trim();
+  return `${dir}::${title}`;
+}
+
+export interface FilterFindingsOptions {
+  /** Minimum confidence (0-100, inclusive) a finding must have to survive. */
+  threshold: number;
+  /** Top-N cap, applied after threshold + dismissal filtering. */
+  cap: number;
+  /** Set of `normalizeFindingClass` values the user has dismissed for this repo. */
+  dismissed: Set<string>;
+}
+
+/** Drop below-threshold and dismissed findings, sort by confidence
+ *  descending, and keep only the top `cap`. */
+export function filterFindings(all: ReviewFinding[], opts: FilterFindingsOptions): ReviewFinding[] {
+  return all
+    .filter((f) => f.confidence >= opts.threshold)
+    .filter((f) => !opts.dismissed.has(normalizeFindingClass(f)))
+    .sort((a, b) => b.confidence - a.confidence)
+    .slice(0, opts.cap);
+}
diff --git a/apps/desktop/src/composables/usePrPanel.ts b/apps/desktop/src/composables/usePrPanel.ts
index 273d959b..effd4c53 100644
--- a/apps/desktop/src/composables/usePrPanel.ts
+++ b/apps/desktop/src/composables/usePrPanel.ts
@@ -29,10 +29,12 @@ import {
   type ForkInfo,
 } from "../utils/backend";
 import { forgeFromRemoteInfo, githubProvider } from "./forge/useForge";
+import { ForgeNotImplementedError } from "./forge/types";
 import { usePrCache, listKey, detailKey } from "./usePrCache";
 import { getPersistedDiffMode, type DiffMode } from "../utils/diffMode";
 import { requireOnline } from "../utils/networkGuard";
 import { t } from "./useI18n";
+import { useReviewIntelligence } from "./useReviewIntelligence";
 
 export const PR_PANEL_KEY = Symbol("prPanel");
 
@@ -65,6 +67,93 @@ export interface PrPanelOptions {
   onRepoMutated?: () => void | Promise<void>;
 }
 
+// ─── Parse unified diff (lazy per-file, A1) ────────────────────────────────
+// `getPRDiff` still fetches the whole PR as one string, but we stop parsing
+// it all up front: `indexDiffFiles` only splits the raw text by `diff --git`
+// headers (cheap), and `parseFileDiff` — the actual hunk/line parse — runs
+// only for the file currently selected (see `ensureFileParsed` below), cached
+// by path so re-selecting a file never re-parses it. Both are pure (no
+// composable state) so they're testable in isolation.
+
+/** Split a raw unified diff into lightweight per-file slices (no hunk parse). */
+export function indexDiffFiles(rawDiff: string): { path: string; raw: string }[] {
+  const slices: { path: string; raw: string }[] = [];
+  if (!rawDiff.trim()) return slices;
+  const lines = rawDiff.split("\n");
+  let currentPath: string | null = null;
+  let currentLines: string[] = [];
+  const flush = () => {
+    if (currentPath !== null) slices.push({ path: currentPath, raw: currentLines.join("\n") });
+  };
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      const match = line.match(/diff --git a\/(.+) b\/(.+)/);
+      currentPath = match ? match[2] : "unknown";
+      currentLines = [line];
+      continue;
+    }
+    if (currentPath !== null) currentLines.push(line);
+  }
+  flush();
+  return slices;
+}
+
+/** Parse one file's raw `diff --git …` slice (as produced by `indexDiffFiles`)
+ *  into hunks/lines. Diff-parsing gotcha (AGENTS.md): context lines are
+ *  detected via `line.startsWith(' ')` — a bare empty string is also treated
+ *  as a (whitespace-stripped) context line, never as a phantom add/delete. */
+export function parseFileDiff(rawFileSlice: string): GitDiff {
+  const file: GitDiff = { path: "unknown", hunks: [] };
+  let currentHunk: DiffHunk | null = null;
+  let oldLine = 0, newLine = 0;
+  for (const line of rawFileSlice.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      const match = line.match(/diff --git a\/(.+) b\/(.+)/);
+      file.path = match ? match[2] : "unknown";
+      currentHunk = null;
+      continue;
+    }
+    if (line.startsWith("index ") || line.startsWith("--- ") || line.startsWith("+++ ") ||
+        line.startsWith("old mode ") || line.startsWith("new mode ") || line.startsWith("new file ") ||
+        line.startsWith("deleted file ") || line.startsWith("similarity index ") ||
+        line.startsWith("rename from ") || line.startsWith("rename to ") || line.startsWith("Binary files ")) continue;
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)/);
+    if (hunkMatch) {
+      currentHunk = {
+        header: line,
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldCount: parseInt(hunkMatch[2] ?? "1", 10),
+        newStart: parseInt(hunkMatch[3], 10),
+        newCount: parseInt(hunkMatch[4] ?? "1", 10),
+        lines: [],
+      };
+      file.hunks.push(currentHunk);
+      oldLine = parseInt(hunkMatch[1], 10);
+      newLine = parseInt(hunkMatch[3], 10);
+      continue;
+    }
+    if (currentHunk) {
+      if (line.startsWith("+")) {
+        currentHunk.lines.push({ type: "add", content: line.substring(1), newLineNo: newLine++ });
+      } else if (line.startsWith("-")) {
+        currentHunk.lines.push({ type: "delete", content: line.substring(1), oldLineNo: oldLine++ });
+      } else if (line.startsWith(" ") || line === "") {
+        currentHunk.lines.push({ type: "context", content: line.startsWith(" ") ? line.substring(1) : line, oldLineNo: oldLine++, newLineNo: newLine++ });
+      }
+    }
+  }
+  return file;
+}
+
+/** Full eager parse — composed from `indexDiffFiles` + `parseFileDiff`.
+ *  Not used on the hot path anymore (see `ensureFileParsed`); kept for
+ *  regression-parity tests and any caller that genuinely wants everything
+ *  parsed up front. */
+export function parseUnifiedDiff(rawDiff: string): GitDiff[] {
+  return indexDiffFiles(rawDiff).map((f) => parseFileDiff(f.raw));
+}
+
 export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
 
   // Disk-persisted SWR cache — paints the list/detail instantly on repo-switch
@@ -127,6 +216,10 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
   const annotationsLoading = ref(false);
   const annotationsLoaded = ref(false);
   const prDiffFiles = ref<GitDiff[]>([]);
+  /** Lightweight per-file index (no hunks) produced by `indexDiffFiles` on
+   *  `loadDiff` — the raw slice each shell in `prDiffFiles` is lazily parsed
+   *  from (A1). */
+  const diffIndex = ref<{ path: string; raw: string }[]>([]);
   const prComments = ref<PrReviewComment[]>([]);
   const prIssueComments = ref<PrReviewComment[]>([]);
   const prReviews = ref<PrReview[]>([]);
@@ -139,8 +232,48 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
   const selectedDiffFile = ref<string | null>(null);
   const diffMode = ref<DiffMode>(getPersistedDiffMode());
 
+  // ─── Viewed-file state (B2) ─────────────────────────────
+  const viewedPaths = ref<Set<string>>(new Set());
+  const hideViewed = ref(false);
+
+  const viewedCount = computed(() => viewedPaths.value.size);
+
+  /** File sidebar list filtered by `hideViewed` (B1 `⇧V`). */
+  const visibleDiffFiles = computed<GitDiff[]>(() =>
+    hideViewed.value ? prDiffFiles.value.filter((f) => !viewedPaths.value.has(f.path)) : prDiffFiles.value,
+  );
+
+  /** `V` — toggle the current file's viewed state, persisted by head SHA. */
+  function toggleViewed(path: string) {
+    if (!path || !selectedPr.value) return;
+    const headSha = prDetail.value?.headSha ?? "";
+    const key = detailKey(cwd.value, selectedPr.value.number);
+    cache.toggleViewed(key, headSha, path);
+    seedViewedFromCache();
+  }
+
+  /** Re-read the viewed set for the selected PR at its current head SHA —
+   *  a stale-headSha cache entry reads as empty (re-push invalidation). */
+  function seedViewedFromCache() {
+    if (!selectedPr.value) {
+      viewedPaths.value = new Set();
+      return;
+    }
+    const headSha = prDetail.value?.headSha ?? "";
+    const stored = cache.getViewed(detailKey(cwd.value, selectedPr.value.number));
+    viewedPaths.value = new Set(stored && stored.headSha === headSha ? stored.paths : []);
+  }
+
+  // Seed/reset viewed state whenever the selected PR's head SHA is known or
+  // changes (cache hit in `selectPr`, fresh fetch in `fetchDetailBundle`, or
+  // a re-push while the detail is open).
+  watch(() => prDetail.value?.headSha, seedViewedFromCache);
+
   // ─── Draft review ──────────────────────────────────────
   const draftReviewComments = ref<PendingReviewComment[]>([]);
+  /** Named badge value (B3) — same as `.length`, but a stable public name
+   *  for the persistent "N in review" chip visible across tabs. */
+  const draftCount = computed(() => draftReviewComments.value.length);
   const showReviewModal = ref(false);
   const submittingReview = ref(false);
 
@@ -315,53 +448,19 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     );
   });
 
-  // ─── Parse unified diff ─────────────────────────────────
-  function parseUnifiedDiff(rawDiff: string): GitDiff[] {
-    const files: GitDiff[] = [];
-    if (!rawDiff.trim()) return files;
-    const lines = rawDiff.split("\n");
-    let currentFile: GitDiff | null = null;
-    let currentHunk: DiffHunk | null = null;
-    let oldLine = 0, newLine = 0;
-    for (const line of lines) {
-      if (line.startsWith("diff --git ")) {
-        if (currentFile) files.push(currentFile);
-        const match = line.match(/diff --git a\/(.+) b\/(.+)/);
-        currentFile = { path: match ? match[2] : "unknown", hunks: [] };
-        currentHunk = null;
-        continue;
-      }
-      if (line.startsWith("index ") || line.startsWith("--- ") || line.startsWith("+++ ") ||
-          line.startsWith("old mode ") || line.startsWith("new mode ") || line.startsWith("new file ") ||
-          line.startsWith("deleted file ") || line.startsWith("similarity index ") ||
-          line.startsWith("rename from ") || line.startsWith("rename to ") || line.startsWith("Binary files ")) continue;
-      const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)/);
-      if (hunkMatch && currentFile) {
-        currentHunk = {
-          header: line,
-          oldStart: parseInt(hunkMatch[1], 10),
-          oldCount: parseInt(hunkMatch[2] ?? "1", 10),
-          newStart: parseInt(hunkMatch[3], 10),
-          newCount: parseInt(hunkMatch[4] ?? "1", 10),
-          lines: [],
-        };
-        currentFile.hunks.push(currentHunk);
-        oldLine = parseInt(hunkMatch[1], 10);
-        newLine = parseInt(hunkMatch[3], 10);
-        continue;
-      }
-      if (currentHunk) {
-        if (line.startsWith("+")) {
-          currentHunk.lines.push({ type: "add", content: line.substring(1), newLineNo: newLine++ });
-        } else if (line.startsWith("-")) {
-          currentHunk.lines.push({ type: "delete", content: line.substring(1), oldLineNo: oldLine++ });
-        } else if (line.startsWith(" ") || line === "") {
-          currentHunk.lines.push({ type: "context", content: line.startsWith(" ") ? line.substring(1) : line, oldLineNo: oldLine++, newLineNo: newLine++ });
-        }
-      }
-    }
-    if (currentFile) files.push(currentFile);
-    return files;
+  // ─── Parse unified diff (lazy per-file, A1) ──────────────
+  const parsedDiffPaths = new Set<string>();
+
+  /** Parse (and cache) the hunks for `path` if not already done. Shells in
+   *  `prDiffFiles` (empty `hunks`) are replaced in place once parsed. */
+  function ensureFileParsed(path: string) {
+    if (parsedDiffPaths.has(path)) return;
+    const slice = diffIndex.value.find((f) => f.path === path);
+    if (!slice) return;
+    const parsed = parseFileDiff(slice.raw);
+    const idx = prDiffFiles.value.findIndex((f) => f.path === path);
+    if (idx !== -1) prDiffFiles.value.splice(idx, 1, parsed);
+    parsedDiffPaths.add(path);
   }
 
   // ─── Data loading ───────────────────────────────────────
@@ -520,7 +619,12 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     prChecks.value = [];
     prAnnotations.value = [];
     annotationsLoaded.value = false;
+    checksLoaded.value = false;
+    issueCommentsLoaded.value = false;
+    fileCountLoaded.value = false;
     prDiffFiles.value = [];
+    diffIndex.value = [];
+    parsedDiffPaths.clear();
     prComments.value = [];
     prIssueComments.value = [];
     prReviews.value = [];
@@ -530,6 +634,8 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     hotspots.value = [];
     fileHistory.value = {};
     selectedDiffFile.value = null;
+    viewedPaths.value = new Set();
+    intel.reset();
     detailTab.value = "info";
   }
 
@@ -543,42 +649,49 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     const cached = cache.getDetail(detailKey(cwd.value, pr.number));
     if (cached) {
       prDetail.value = cached.detail;
-      prChecks.value = cached.checks;
+      prChecks.value = cached.checks ?? [];
       prComments.value = cached.comments;
-      prIssueComments.value = cached.issueComments;
+      prIssueComments.value = cached.issueComments ?? [];
       prReviews.value = cached.reviews;
+      // A cached checks/issueComments array might just be the [] default
+      // above rather than a real prior fetch — leave the loaded flags false
+      // either way so the tab's lazy loader still fires once to get the
+      // real data (cheap no-op if it turns out to genuinely be empty).
       detailRefreshing.value = true;
     } else {
       detailLoading.value = true;
     }
+    // B3 — restore any draft review comments staged before the detail was
+    // last closed, so switching PRs never silently drops staged feedback.
+    draftReviewComments.value = cache.getDraft(detailKey(cwd.value, pr.number)) ?? [];
     await fetchDetailBundle(pr, { silentError: !!cached });
   }
 
   /**
-   * Fetch (or revalidate) the full detail bundle for `pr` and write it back to
-   * the cache. The caller sets `detailLoading` / `detailRefreshing` before
-   * awaiting; both are cleared here. `silentError` keeps the stale bundle on
-   * screen instead of surfacing an error (used for cache-hit + background
-   * revalidation, where there is already content to show).
+   * Fetch (or revalidate) the hot-path detail bundle for `pr` and write it
+   * back to the cache. The caller sets `detailLoading` / `detailRefreshing`
+   * before awaiting; both are cleared here. `silentError` keeps the stale
+   * bundle on screen instead of surfacing an error (used for cache-hit +
+   * background revalidation, where there is already content to show).
+   *
+   * A3 (v3.6.0): only `getPR` + `listComments` + `listReviews` run here —
+   * `getCIChecks`/`listIssueComments`/`gitFileCount` are deferred to their
+   * tab's lazy loader (`loadChecks`/`loadIssueComments`/`loadRepoFileCount`)
+   * below, cutting the hot-path forge calls from 6 to 3.
    */
   async function fetchDetailBundle(pr: PullRequest, { silentError }: { silentError: boolean }) {
     const key = detailKey(cwd.value, pr.number);
     detailError.value = null;
     try {
-      const [detail, checks, comments, issueComments, reviews, fileCount] = await Promise.all([
+      const [detail, comments, reviews] = await Promise.all([
         forge.value.getPR(cwd.value, pr.number),
-        forge.value.getCIChecks(cwd.value, pr.number).catch(() => [] as CICheck[]),
         forge.value.listComments(cwd.value, pr.number).catch(() => [] as PrReviewComment[]),
-        forge.value.listIssueComments?.(cwd.value, pr.number).catch(() => [] as PrReviewComment[]) ?? Promise.resolve([] as PrReviewComment[]),
         forge.value.listReviews(cwd.value, pr.number).catch(() => [] as PrReview[]),
-        gitFileCount(cwd.value).catch(() => 0),
       ]);
       // Ignore a stale response if the user moved on to another PR meanwhile.
       if (selectedPr.value?.number !== pr.number) return;
       prDetail.value = detail;
-      prChecks.value = checks;
       prComments.value = comments;
-      prIssueComments.value = issueComments;
       prReviews.value = reviews;
 
       // Azure DevOps API doesn't include comment counts in the PR object.
@@ -588,8 +701,7 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
         prDetail.value.comments = 0;
       }
 
-      totalRepoFiles.value = fileCount;
-      cache.setDetail(key, { detail, checks, comments, issueComments, reviews });
+      cache.setDetail(key, { detail, comments, reviews, checks: prChecks.value, issueComments: prIssueComments.value });
     } catch (err: any) {
       // Keep the cached bundle on screen if revalidation failed.
       if (!silentError) detailError.value = err.message;
@@ -599,6 +711,57 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     }
   }
 
+  // ─── Lazy detail loaders (A3) — one flight per PR, fired by the tab
+  // that actually needs the data (mirrors `loadAnnotations`'s guard pattern).
+  const checksLoaded = ref(false);
+  const checksLoading = ref(false);
+  const issueCommentsLoaded = ref(false);
+  const issueCommentsLoading = ref(false);
+  const fileCountLoaded = ref(false);
+  const fileCountLoading = ref(false);
+
+  async function loadChecks() {
+    if (!selectedPr.value || checksLoaded.value || checksLoading.value) return;
+    checksLoading.value = true;
+    try {
+      prChecks.value = await forge.value.getCIChecks(cwd.value, selectedPr.value.number);
+      checksLoaded.value = true;
+      persistDetailCache();
+    } catch {
+      checksLoaded.value = true; // non-fatal — checks tab simply stays empty
+    } finally {
+      checksLoading.value = false;
+    }
+  }
+
+  async function loadIssueComments() {
+    if (!selectedPr.value || issueCommentsLoaded.value || issueCommentsLoading.value) return;
+    issueCommentsLoading.value = true;
+    try {
+      prIssueComments.value =
+        (await forge.value.listIssueComments?.(cwd.value, selectedPr.value.number)) ?? [];
+      issueCommentsLoaded.value = true;
+      persistDetailCache();
+    } catch {
+      issueCommentsLoaded.value = true;
+    } finally {
+      issueCommentsLoading.value = false;
+    }
+  }
+
+  async function loadRepoFileCount() {
+    if (fileCountLoaded.value || fileCountLoading.value) return;
+    fileCountLoading.value = true;
+    try {
+      totalRepoFiles.value = await gitFileCount(cwd.value);
+      fileCountLoaded.value = true;
+    } catch {
+      fileCountLoaded.value = true;
+    } finally {
+      fileCountLoading.value = false;
+    }
+  }
+
   /** Re-fetch the currently open detail bundle in the background (poll-driven). */
   async function revalidateOpenDetail() {
     const pr = selectedPr.value;
@@ -633,8 +796,15 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     detailLoading.value = true;
     try {
       const raw = await forge.value.getPRDiff(cwd.value, selectedPr.value.number);
-      prDiffFiles.value = parseUnifiedDiff(raw);
-      if (prDiffFiles.value.length) selectedDiffFile.value = prDiffFiles.value[0].path;
+      // A1: index only (cheap) — shells render the file sidebar instantly.
+      // Hunks are parsed lazily, per file, by `ensureFileParsed`.
+      diffIndex.value = indexDiffFiles(raw);
+      parsedDiffPaths.clear();
+      prDiffFiles.value = diffIndex.value.map((f) => ({ path: f.path, hunks: [] }));
+      if (prDiffFiles.value.length) {
+        selectedDiffFile.value = prDiffFiles.value[0].path;
+        ensureFileParsed(selectedDiffFile.value);
+      }
     } catch (err: any) {
       detailError.value = err.message;
     } finally {
@@ -642,6 +812,11 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     }
   }
 
+  // A1: parse a newly-selected file's hunks on demand (once, cached by path).
+  watch(selectedDiffFile, (path) => {
+    if (path) ensureFileParsed(path);
+  });
+
   /**
    * Load check-run annotations (v2.18). Lazy: fired the first time the
    * Diff or Checks tab is opened for the selected PR. One flight max —
@@ -684,16 +859,35 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     return map;
   });
 
+  /**
+   * Unified AI + static Intelligence surface (E2) — pre-review findings
+   * (C1-C4), PR summary (D1), static heuristic flags, and the merged
+   * `LineAnnotation` stream `PrInlineDiff` renders per file. `usePrPanel`
+   * composes this rather than owning the AI/static state itself.
+   */
+  const intel = useReviewIntelligence({
+    cwd, selectedPr, prDetail, detailTab, loadDiff, diffIndex, annotationsByFile,
+  });
+
   watch(detailTab, async (tab) => {
     if (tab === "diff") {
       loadDiff();
       loadAnnotations();
+      loadChecks(); // A3: checks gutter/badges on the Diff tab too, not just Checks
+    }
+    if (tab === "checks") {
+      loadAnnotations();
+      loadChecks();
+    }
+    if (tab === "info") {
+      loadIssueComments();
+      void intel.loadSummary();
     }
-    if (tab === "checks") loadAnnotations();
     if (tab === "intelligence") {
       if (prDiffFiles.value.length === 0) await loadDiff();
       if (!hotspots.value.length) loadHotspots();
       if (!Object.keys(fileHistory.value).length) loadFileHistory();
+      loadRepoFileCount();
     }
   });
 
@@ -821,13 +1015,28 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     } catch (err: any) { error.value = err.message; }
   }
 
+  /** True when the active forge supports editing a review comment (F2) — the
+   *  thread hides the edit affordance rather than calling into a forge that
+   *  throws `ForgeNotImplementedError`. Azure has no edit endpoint wired yet. */
+  const forgeSupportsCommentEdit = computed(() => forge.value.name !== "azure");
+  /** Same contract as `forgeSupportsCommentEdit`, for delete (F2). */
+  const forgeSupportsCommentDelete = computed(() => forge.value.name !== "azure");
+
+  /** Same unsupported-is-silent contract as `handleDismissReview` — a forge
+   *  that throws `ForgeNotImplementedError` (e.g. Azure) is treated as
+   *  unsupported rather than surfaced as an error banner. `forgeSupports*`
+   *  hides the action before this can even be called, so this guard is
+   *  defense-in-depth, not the primary UX. */
   async function handleEditComment(id: number, body: string) {
     try {
       await forge.value.updateComment(cwd.value, id, body);
       const idx = prComments.value.findIndex((c) => c.id === id);
       if (idx !== -1) prComments.value[idx] = { ...prComments.value[idx], body, updated_at: new Date().toISOString() };
       persistDetailCache();
-    } catch (err: any) { error.value = err.message; }
+    } catch (err: any) {
+      if (err instanceof ForgeNotImplementedError) return;
+      error.value = err.message;
+    }
   }
 
   async function handleDeleteComment(id: number) {
@@ -836,7 +1045,10 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
       prComments.value = prComments.value.filter((c) => c.id !== id && c.in_reply_to_id !== id);
       if (prDetail.value && prDetail.value.reviewComments > 0) prDetail.value.reviewComments--;
       persistDetailCache();
-    } catch (err: any) { error.value = err.message; }
+    } catch (err: any) {
+      if (err instanceof ForgeNotImplementedError) return;
+      error.value = err.message;
+    }
   }
 
   function handleApplySuggestion(suggestion: string, startLine: number | null, endLine: number | null) {
@@ -844,6 +1056,14 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     success.value = t("pr.success.suggestionCopied", startLine ?? "?", endLine ?? "?");
   }
 
+  /** Write the current draft back to the SWR cache (B3) — survives detail
+   *  close/reopen. No-op when no PR is selected (shouldn't happen in
+   *  practice, since only the open detail's compose box can call this). */
+  function persistDraft() {
+    if (!selectedPr.value) return;
+    cache.setDraft(detailKey(cwd.value, selectedPr.value.number), draftReviewComments.value);
+  }
+
   function handleAddToReview(params: {
     path: string; line: number; side: "LEFT" | "RIGHT";
     start_line?: number; start_side?: "LEFT" | "RIGHT"; body: string;
@@ -854,6 +1074,7 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
       ...(params.start_side !== undefined ? { start_side: params.start_side } : {}),
       body: params.body,
     });
+    persistDraft();
     success.value = t("pr.success.commentAddedToReview", draftReviewComments.value.length);
   }
 
@@ -865,9 +1086,13 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     if (!selectedPr.value) return;
     submittingReview.value = true;
     try {
-      await forge.value.submitReview(cwd.value, selectedPr.value.number, opts);
+      await forge.value.submitReview(cwd.value, selectedPr.value.number, {
+        ...opts,
+        viewedFiles: [...viewedPaths.value],
+      });
       showReviewModal.value = false;
       draftReviewComments.value = [];
+      cache.clearDraft(detailKey(cwd.value, selectedPr.value.number));
       const [reviews, comments] = await Promise.all([
         forge.value.listReviews(cwd.value, selectedPr.value.number).catch(() => [] as PrReview[]),
         forge.value.listComments(cwd.value, selectedPr.value.number).catch(() => [] as PrReviewComment[]),
@@ -883,6 +1108,48 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     }
   }
 
+  /** True when the active forge implements `dismissReview` (B4) — the Info
+   *  tab uses this to hide the action rather than show one that throws. */
+  const forgeSupportsDismissReview = computed(() => typeof forge.value.dismissReview === "function");
+  /** True when the active forge implements `requestReviewers` (B4). */
+  const forgeSupportsRequestReviewers = computed(() => typeof forge.value.requestReviewers === "function");
+
+  /** Dismiss a submitted review (B4). Forges that don't support it
+   *  (`ForgeNotImplementedError`, or simply omitting the method) are
+   *  treated as unsupported — the Info tab hides the action via
+   *  `forgeSupportsDismissReview` before this can even be called, so this
+   *  guard is defense-in-depth, not the primary UX. */
+  async function handleDismissReview(reviewId: number, message?: string) {
+    if (!selectedPr.value || !forge.value.dismissReview) return;
+    try {
+      await forge.value.dismissReview(cwd.value, selectedPr.value.number, reviewId, message);
+      prReviews.value = await forge.value.listReviews(cwd.value, selectedPr.value.number).catch(() => prReviews.value);
+      persistDetailCache();
+      success.value = t("pr.reviews.dismissed");
+    } catch (err: any) {
+      if (err instanceof ForgeNotImplementedError) return;
+      error.value = err.message;
+    }
+  }
+
+  /** Request reviewers on the open PR (B4). Same unsupported-is-silent
+   *  contract as `handleDismissReview`. */
+  async function handleRequestReviewers(logins: string[]) {
+    if (!selectedPr.value || !forge.value.requestReviewers || !logins.length) return;
+    try {
+      await forge.value.requestReviewers(cwd.value, selectedPr.value.number, logins);
+      const detail = await forge.value.getPR(cwd.value, selectedPr.value.number).catch(() => null);
+      if (detail) {
+        prDetail.value = detail;
+        persistDetailCache();
+      }
+      success.value = t("pr.reviews.reviewersRequested");
+    } catch (err: any) {
+      if (err instanceof ForgeNotImplementedError) return;
+      error.value = err.message;
+    }
+  }
+
   // ─── Intelligence handlers ──────────────────────────────
   async function loadConflictPreview() {
     if (!selectedPr.value || conflictLoading.value) return;
@@ -1016,6 +1283,9 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
       // Catch up immediately if a full interval elapsed while hidden, but don't
       // refetch on every brief alt-tab.
       if (Date.now() - _lastPoll >= REVALIDATE_INTERVAL_MS) pollTick();
+      // C3 — resume the pre-review queue (reuses this listener rather than
+      // adding a second `visibilitychange` handler).
+      intel.resumePreReviewQueue();
     }
   }
 
@@ -1086,12 +1356,26 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     mergingPr, mergeMethod,
     selectedPr, prDetail, prChecks, checksWithConflict, prDiffFiles, prComments, prIssueComments, prReviews,
     detailLoading, detailRefreshing, detailError, detailTab, selectedDiffFile, diffMode,
+    // Viewed-file state (B2)
+    viewedPaths, viewedCount, hideViewed, visibleDiffFiles, toggleViewed,
     // CI annotations (v2.18)
     prAnnotations, annotationsLoading, annotationsLoaded,
     annotationCountByCheck, annotationsByFile, loadAnnotations,
-    draftReviewComments, showReviewModal, submittingReview,
+    draftReviewComments, draftCount, showReviewModal, submittingReview,
     conflictPreview, conflictLoading, conflictError,
     hotspots, hotspotsLoading, totalRepoFiles, fileHistory, fileHistoryLoading,
+    // Unified AI + static Intelligence (E2) — composed, not owned
+    lineAnnotationsByFile: intel.lineAnnotationsByFile,
+    mergedAnnotationsByFile: intel.mergedAnnotationsByFile,
+    staticFlags: intel.staticFlags,
+    preReviewFindings: intel.preReviewFindings,
+    preReviewProgress: intel.preReviewProgress,
+    preReviewRunning: intel.preReviewRunning,
+    dismissFinding: intel.dismissFinding,
+    prSummary: intel.prSummary,
+    prSummaryLoading: intel.prSummaryLoading,
+    loadSummary: intel.loadSummary,
+    regenerateSummary: intel.regenerateSummary,
     // Pagination (v2.8.5)
     hasMore, loadingMore,
     // Computed
@@ -1099,9 +1383,12 @@ export function usePrPanel(cwd: Ref<string>, opts: PrPanelOptions = {}) {
     commentsForFile, commentCount, mergeReadiness, mergeBlocked, mergeBlockedReason, selectedDiff, displayedPrs,
     // Actions
     init, ensurePrsLoaded, loadRemote, loadPrs, loadMorePrs, loadCurrentUser, selectPr, loadDiff,
+    revalidateOpenDetail,
     createPr, checkoutPr, mergePr, convertDraftToReady,
     handleCreateComment, handleReplyComment, handleEditComment,
     handleDeleteComment, handleApplySuggestion, handleAddToReview, handleSubmitReview,
+    handleDismissReview, handleRequestReviewers, forgeSupportsDismissReview, forgeSupportsRequestReviewers,
+    forgeSupportsCommentEdit, forgeSupportsCommentDelete,
     loadConflictPreview, loadHotspots, loadFileHistory,
     // Helpers
     timeAgo, checkIcon, checksIcon, mergeableIcon, renderBody,
diff --git a/apps/desktop/src/composables/usePrPreReview.ts b/apps/desktop/src/composables/usePrPreReview.ts
new file mode 100644
index 00000000..5d192fe3
--- /dev/null
+++ b/apps/desktop/src/composables/usePrPreReview.ts
@@ -0,0 +1,280 @@
+/**
+ * usePrPreReview.ts
+ *
+ * Local, multi-hop AI pre-review engine (C1, v3.6.0) — Greptile-style,
+ * opt-in, background pass over a PR's touched files:
+ *   1. Diff hop    — hunks from the already-parsed `GitDiff` (A1).
+ *   2. Dependency hop — import specifiers extracted from the file's touched
+ *      lines (`extractImportSources` from `@gitwand/core`, extraction only —
+ *      no resolved graph, that's v4.0), cross-referenced against the *other*
+ *      files in the same diff to flag "imported by N diff files".
+ *   3. History hop — `git blame` on the changed lines (`getGitBlame`,
+ *      forge-agnostic — works identically on all 4 forges).
+ *   4. Findings    — one LLM call per file, strict JSON, defensively parsed.
+ *
+ * `usePrReviewQueue` (C3) sequences `analyzeFile` across a PR's files;
+ * `useReviewIntelligence` (E2) composes this engine into the unified
+ * Intelligence surface.
+ */
+import { extractImportSources } from "@gitwand/core";
+import type { GitDiff, BlameLine } from "../utils/backend";
+import { localeToAiLanguage } from "./prAiLocale";
+import { getGitBlame } from "../utils/backend";
+import { useAIProvider } from "./useAIProvider";
+
+export interface ReviewFinding {
+  /** Stable hash of path+line+title — used for dismissal (C2) and nav (C4). */
+  id: string;
+  path: string;
+  line: number;
+  side: "LEFT" | "RIGHT";
+  severity: "risk" | "suggestion" | "nit";
+  /** 0-100. */
+  confidence: number;
+  title: string;
+  detail: string;
+}
+
+export interface AnalyzeFileOptions {
+  cwd: string;
+  /** UI locale — drives the response language. */
+  locale?: string;
+  /** The other files touched in this PR (excluding `file`) — used for the
+   *  dependency-hop cross-reference. */
+  otherDiffFiles: GitDiff[];
+  /** Max characters of hunk text sent per file (default 6 000 — files get
+   *  a bigger budget than the single-hunk critique since findings are
+   *  file-scoped, not hunk-scoped). */
+  maxFileChars?: number;
+}
+
+// ─── Hop 2: dependency (extraction + cross-reference, no graph) ───────────
+
+/** Import specifiers touched by `file`'s hunks (added/context lines only —
+ *  deleted lines carry no signal about the *current* state of the file). */
+export function importSourcesForFile(file: GitDiff): string[] {
+  const lines: string[] = [];
+  for (const hunk of file.hunks) {
+    for (const dl of hunk.lines) {
+      if (dl.type !== "delete") lines.push(dl.content);
+    }
+  }
+  return extractImportSources(lines.join("\n"));
+}
+
+/** True when a relative import `specifier` (as written in another file)
+ *  plausibly resolves to `path` — basename match, extension-insensitive.
+ *  Bare package specifiers (no leading `.`) never match a repo-local path. */
+function specifierMatchesPath(specifier: string, path: string): boolean {
+  if (!specifier.startsWith(".")) return false;
+  const stripExt = (s: string) => s.replace(/\.(ts|tsx|js|jsx|mjs|cjs|vue)$/, "");
+  const specBase = stripExt(specifier.split("/").pop() ?? "");
+  const pathBase = stripExt(path.split("/").pop() ?? "");
+  return !!specBase && specBase === pathBase;
+}
+
+/** How many of `otherFiles` import `file` — the "imported by N diff files"
+ *  signal. Heuristic basename matching, not a resolved graph (v4.0). */
+export function computeImportedByCount(file: GitDiff, otherFiles: GitDiff[]): number {
+  let count = 0;
+  for (const other of otherFiles) {
+    if (other.path === file.path) continue;
+    const sources = importSourcesForFile(other);
+    if (sources.some((s) => specifierMatchesPath(s, file.path))) count++;
+  }
+  return count;
+}
+
+// ─── Hop 3: history (blame on changed lines) ──────────────────────────────
+
+/** Line numbers (new side) touched by `file`'s hunks — add + context, since
+ *  a context line's surrounding history can still be relevant, but capped
+ *  to the lines the diff actually shows to keep the blame summary tight. */
+function changedNewLineNumbers(file: GitDiff): Set<number> {
+  const nums = new Set<number>();
+  for (const hunk of file.hunks) {
+    for (const dl of hunk.lines) {
+      if (dl.type === "add" && dl.newLineNo != null) nums.add(dl.newLineNo);
+    }
+  }
+  return nums;
+}
+
+/** Deduped "author: summary" lines for the blame entries covering `file`'s
+ *  added lines. Best-effort — `getGitBlame` reflects the current checkout,
+ *  which may already include this PR's own commits if the branch is
+ *  checked out locally (no base-relative blame command exists yet). */
+export function summarizeBlameForFile(blame: BlameLine[], file: GitDiff): string[] {
+  const lineNos = changedNewLineNumbers(file);
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const b of blame) {
+    if (!lineNos.has(b.finalLine)) continue;
+    const key = `${b.author}::${b.summary}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(`${b.author}: ${b.summary}`);
+  }
+  return out;
+}
+
+// ─── Hop 4: findings (strict JSON, defensive parse) ───────────────────────
+
+function buildSystemPrompt(locale: string): string {
+  const lang = localeToAiLanguage(locale);
+  return `You are a senior engineer doing a pre-review pass on one file of a pull request.
+
+You will receive:
+- The file path.
+- The file's touched hunks (unified-diff content).
+- A dependency signal: how many other files in this same PR import this file.
+- A brief history signal: recent commit summaries that touched the lines
+  now being changed.
+
+Produce a JSON array of findings — an empty array \`[]\` when there is
+nothing worth flagging:
+[
+  {
+    "line": <number, the new-file line number>,
+    "side": "LEFT" | "RIGHT",
+    "severity": "risk" | "suggestion" | "nit",
+    "confidence": <0-100>,
+    "title": "<short title>",
+    "detail": "<1-3 sentences in ${lang}>"
+  }
+]
+
+Severity scale:
+- "risk"       → likely bug, security issue, breaking change.
+- "suggestion" → concrete improvement (edge case, missing test, naming).
+- "nit"        → minor style/readability, non-blocking.
+
+Rules:
+- confidence reflects how sure you are this is a real, actionable issue —
+  not how severe it is. A risky-looking but uncertain guess should have a
+  LOW confidence, not a high one.
+- Weigh the dependency signal: a file imported by many other diff files in
+  this PR deserves more scrutiny (its bugs have wider blast radius).
+- Never invent symbols or behaviour not shown in the hunks.
+- Write "detail" in ${lang}. Output ONLY the JSON array, no prose, no code
+  fences.`;
+}
+
+function fileToHunkText(file: GitDiff, maxChars: number): string {
+  const lines: string[] = [];
+  for (const hunk of file.hunks) {
+    lines.push(hunk.header);
+    for (const dl of hunk.lines) {
+      const marker = dl.type === "add" ? "+" : dl.type === "delete" ? "-" : " ";
+      const lineNo = dl.type === "delete" ? dl.oldLineNo : dl.newLineNo;
+      lines.push(`${marker}[${lineNo ?? "?"}] ${dl.content}`);
+    }
+  }
+  const joined = lines.join("\n");
+  return joined.length <= maxChars ? joined : joined.slice(0, maxChars) + "\n... (truncated)";
+}
+
+export function buildUserPrompt(
+  file: GitDiff,
+  importedByCount: number,
+  blameSummaries: string[],
+  maxFileChars: number,
+): string {
+  const parts: string[] = [];
+  parts.push(`File: ${file.path}`);
+  parts.push(`Imported by ${importedByCount} other file(s) in this diff.`);
+  if (blameSummaries.length) {
+    parts.push("Recent history on the changed lines:");
+    for (const s of blameSummaries.slice(0, 10)) parts.push(`- ${s}`);
+  }
+  parts.push("");
+  parts.push("--- hunks ---");
+  parts.push(fileToHunkText(file, maxFileChars));
+  return parts.join("\n");
+}
+
+/** Simple string hash (djb2) — stable across runs for the same input, used
+ *  as the finding's dismissal/nav id. Not cryptographic; collisions are an
+ *  acceptable risk for this UI-only identity. */
+function hashId(s: string): string {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = ((h << 5) + h + s.charCodeAt(i)) | 0;
+  return (h >>> 0).toString(36);
+}
+
+/**
+ * Defensive JSON-array parse — recovers from a ```json fence or surrounding
+ * prose (mirrors `usePrHunkCritique.ts`'s object parse, generalized to an
+ * array). Clamps confidence to 0-100, coerces an unknown severity to
+ * "suggestion", and drops entries missing `line`/`title`.
+ */
+export function parseFindings(raw: string, path: string): ReviewFinding[] {
+  let s = raw.trim();
+  const fence = s.match(/^```(?:json)?\s*\n([\s\S]*?)\n```\s*$/i);
+  if (fence) s = fence[1].trim();
+  const start = s.indexOf("[");
+  const end = s.lastIndexOf("]");
+  if (start !== -1 && end > start) s = s.slice(start, end + 1);
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(s);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+
+  const out: ReviewFinding[] = [];
+  for (const raw of parsed) {
+    if (!raw || typeof raw !== "object") continue;
+    const r = raw as Record<string, unknown>;
+    const line = typeof r.line === "number" ? r.line : NaN;
+    const title = typeof r.title === "string" ? r.title.trim() : "";
+    if (!Number.isFinite(line) || !title) continue;
+    const side: "LEFT" | "RIGHT" = r.side === "LEFT" ? "LEFT" : "RIGHT";
+    const severityRaw = r.severity;
+    const severity: ReviewFinding["severity"] =
+      severityRaw === "risk" || severityRaw === "nit" ? severityRaw : "suggestion";
+    const confidenceRaw = typeof r.confidence === "number" ? r.confidence : 50;
+    const confidence = Math.max(0, Math.min(100, Math.round(confidenceRaw)));
+    const detail = typeof r.detail === "string" ? r.detail.trim() : "";
+    out.push({
+      id: hashId(`${path}:${line}:${title}`),
+      path,
+      line,
+      side,
+      severity,
+      confidence,
+      title,
+      detail,
+    });
+  }
+  return out;
+}
+
+export function usePrPreReview() {
+  const ai = useAIProvider();
+
+  /** Analyze one file — the concurrency-1 unit `usePrReviewQueue` (C3)
+   *  sequences over a PR's touched files. Returns `[]` gracefully on any
+   *  failure (AI unavailable, malformed response, blame lookup failure) —
+   *  a single file's issue must never abort the whole pre-review pass. */
+  async function analyzeFile(file: GitDiff, opts: AnalyzeFileOptions): Promise<ReviewFinding[]> {
+    if (!ai.isAvailable.value || !file.hunks.length) return [];
+    try {
+      const importedByCount = computeImportedByCount(file, opts.otherDiffFiles);
+      const blame = await getGitBlame(opts.cwd, file.path).catch(() => [] as BlameLine[]);
+      const blameSummaries = summarizeBlameForFile(blame, file);
+
+      const systemPrompt = buildSystemPrompt(opts.locale ?? "en");
+      const userPrompt = buildUserPrompt(file, importedByCount, blameSummaries, opts.maxFileChars ?? 6000);
+      const raw = await ai.rawPrompt(systemPrompt, userPrompt);
+      if (!raw) return [];
+      return parseFindings(raw, file.path);
+    } catch {
+      return [];
+    }
+  }
+
+  return { analyzeFile };
+}
diff --git a/apps/desktop/src/composables/usePrReviewKeymap.ts b/apps/desktop/src/composables/usePrReviewKeymap.ts
new file mode 100644
index 00000000..bb0ad4b4
--- /dev/null
+++ b/apps/desktop/src/composables/usePrReviewKeymap.ts
@@ -0,0 +1,77 @@
+/**
+ * usePrReviewKeymap.ts
+ *
+ * Pure GitHub-standard keymap resolver for the PR review Diff tab (B1,
+ * v3.6.0). Mirrors `resolveTerminalShortcut` (`useTerminalSessions.ts`):
+ * a pure function from a `KeyboardEvent` + focus context to a discriminated
+ * action, with no side effects and no Vue state — the host (`PrDetailView.vue`)
+ * owns the listener and dispatches.
+ */
+
+export type PrReviewAction =
+  | "next-hunk"
+  | "prev-hunk"
+  | "next-file"
+  | "prev-file"
+  | "toggle-viewed"
+  | "toggle-hide-viewed"
+  | "filter-files"
+  | "comment-hunk"
+  | "help"
+  | "next-finding"
+  | "prev-finding"
+  | "submit-review";
+
+/** True when `el` is a text input, textarea, select, or contenteditable —
+ *  the keymap must stay completely inert while the user is typing there. */
+export function isEditableTarget(el: EventTarget | null): boolean {
+  if (!(el instanceof HTMLElement)) return false;
+  const tag = el.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  // `isContentEditable` computes inherited editability but jsdom doesn't
+  // fully implement it — check the attribute directly too so this guard is
+  // reliable in both the browser and the test environment.
+  if (el.isContentEditable) return true;
+  const attr = el.getAttribute("contenteditable");
+  if (attr === "" || attr === "true") return true;
+  return false;
+}
+
+/**
+ * Resolve a keydown into a PR-review action, or `null` when the key is
+ * unmapped, the panel isn't focused, or an unrelated modifier is held.
+ * Never maps `Escape` or `⌘⇧L` — those stay owned by `App.vue`'s global
+ * handlers, so returning `null` here lets them bubble untouched.
+ */
+export function resolvePrReviewShortcut(
+  e: KeyboardEvent,
+  ctx: { focused: boolean },
+): PrReviewAction | null {
+  if (!ctx.focused) return null;
+
+  const mod = e.metaKey || e.ctrlKey;
+
+  // ⌘Enter / Ctrl+Enter — submit the pending review (B3). Checked before the
+  // general modifier bail below since this is the one mapped combo that
+  // requires a modifier.
+  if (mod && e.key === "Enter") return "submit-review";
+
+  // Every other action is a bare letter/punctuation key — any other
+  // modifier (Ctrl+J, Alt+V, …) is noise, not a shortcut.
+  if (mod || e.altKey) return null;
+
+  switch (e.key) {
+    case "j": return "next-hunk";
+    case "J": return "next-file";
+    case "k": return "prev-hunk";
+    case "K": return "prev-file";
+    case "v": return "toggle-viewed";
+    case "V": return "toggle-hide-viewed";
+    case "t": return "filter-files";
+    case "c": return "comment-hunk";
+    case "?": return "help";
+    case "n": return "next-finding";
+    case "p": return "prev-finding";
+    default: return null;
+  }
+}
diff --git a/apps/desktop/src/composables/usePrReviewNav.ts b/apps/desktop/src/composables/usePrReviewNav.ts
new file mode 100644
index 00000000..bf251c32
--- /dev/null
+++ b/apps/desktop/src/composables/usePrReviewNav.ts
@@ -0,0 +1,144 @@
+/**
+ * usePrReviewNav.ts
+ *
+ * Keyboard-nav dispatch for the PR review Diff tab (B1, v3.6.0) — extracted
+ * out of `PrDetailView.vue` so the hunk/file cursor logic is unit-testable
+ * without mounting the (very large) host component, per AGENTS.md's
+ * "business logic belongs in composables" rule.
+ *
+ * The host still owns the `keydown` listener and `resolvePrReviewShortcut`
+ * call (focus-guarding, `preventDefault`); this composable only reacts to
+ * the resolved `PrReviewAction`.
+ */
+import { ref, nextTick, type Ref } from "vue";
+import type { GitDiff } from "../utils/backend";
+import type { PrReviewAction } from "./usePrReviewKeymap";
+import type { ReviewFinding } from "./usePrPreReview";
+
+/** Minimal duck-typed row shape (mirrors `PrInlineDiff.vue`'s internal
+ *  `DiffRow`) — enough to locate the row for a given finding's line without
+ *  this composable depending on the component's exact row-model type. */
+export interface DiffRowLike {
+  kind: string;
+  dl?: { type: string; oldLineNo?: number; newLineNo?: number };
+}
+
+export interface PrInlineDiffHandle {
+  scrollToHunk(hunkIdx: number): void;
+  scrollToLine(rowIdx: number): void;
+  openComposeAtHunk(hunkIdx: number): void;
+  rows: DiffRowLike[];
+}
+
+export interface UsePrReviewNavOptions {
+  prDiffFiles: Ref<GitDiff[]>;
+  selectedDiffFile: Ref<string | null>;
+  /** The currently-selected file's parsed diff (hunks), or null. */
+  selectedDiff: Ref<GitDiff | null>;
+  /** Ref to the mounted `PrInlineDiff` instance (or null before mount). */
+  diffHandle: Ref<PrInlineDiffHandle | null>;
+  onHelp: () => void;
+  /** B2 — toggle the current file's viewed state / the hide-viewed filter. */
+  onToggleViewed: (path: string) => void;
+  hideViewed: Ref<boolean>;
+  /** B3 — `⌘Enter` opens the review modal (never submits directly — the
+   *  event/body choice still lives in `PrReviewModal`). No-op mid-submit. */
+  onSubmitReview: () => void;
+  submittingReview: Ref<boolean>;
+  /** C4 — confidence-sorted AI pre-review findings, across the whole PR
+   *  (not just the selected file) — `N`/`P` cycle through all of them. */
+  findings: Ref<ReviewFinding[]>;
+}
+
+export function usePrReviewNav(opts: UsePrReviewNavOptions) {
+  /** Which hunk `J`/`K` currently point at, in the selected file. */
+  const currentHunkIdx = ref(0);
+
+  function currentFileIndex(): number {
+    return opts.prDiffFiles.value.findIndex((f) => f.path === opts.selectedDiffFile.value);
+  }
+
+  /** `⇧J`/`⇧K` — move to the next/prev file in the sidebar, wrapping around. */
+  function goToFile(delta: 1 | -1) {
+    const files = opts.prDiffFiles.value;
+    if (!files.length) return;
+    const idx = currentFileIndex();
+    const next = ((idx === -1 ? 0 : idx) + delta + files.length) % files.length;
+    opts.selectedDiffFile.value = files[next].path;
+    currentHunkIdx.value = 0;
+  }
+
+  /** `J`/`K` — move to the next/prev hunk, crossing into the next/prev file
+   *  once past the last/first hunk of the current one (per spec B1). */
+  function goToHunk(delta: 1 | -1) {
+    const hunkCount = opts.selectedDiff.value?.hunks.length ?? 0;
+    if (!hunkCount) {
+      goToFile(delta);
+      return;
+    }
+    const next = currentHunkIdx.value + delta;
+    if (next < 0 || next >= hunkCount) {
+      goToFile(delta);
+      nextTick(() => {
+        const newCount = opts.selectedDiff.value?.hunks.length ?? 0;
+        currentHunkIdx.value = delta > 0 ? 0 : Math.max(0, newCount - 1);
+        opts.diffHandle.value?.scrollToHunk(currentHunkIdx.value);
+      });
+      return;
+    }
+    currentHunkIdx.value = next;
+    opts.diffHandle.value?.scrollToHunk(next);
+  }
+
+  /** Which finding `N`/`P` currently point at, across the whole PR. -1
+   *  means "none yet" — the first `N` press lands on index 0. */
+  const currentFindingIdx = ref(-1);
+
+  /** `N`/`P` — cycle through the confidence-sorted findings list, wrapping
+   *  around, switching file and scrolling to the finding's line. */
+  function jumpToFinding(delta: 1 | -1) {
+    const list = opts.findings.value;
+    if (!list.length) return;
+    const base = currentFindingIdx.value === -1 ? (delta > 0 ? -1 : 0) : currentFindingIdx.value;
+    const idx = ((base + delta) % list.length + list.length) % list.length;
+    currentFindingIdx.value = idx;
+    const finding = list[idx];
+    opts.selectedDiffFile.value = finding.path;
+    nextTick(() => {
+      const rows = opts.diffHandle.value?.rows ?? [];
+      const rowIdx = rows.findIndex((r) => {
+        if (r.kind !== "line" || !r.dl) return false;
+        const lineNo = r.dl.type === "delete" ? r.dl.oldLineNo : r.dl.newLineNo;
+        return lineNo === finding.line;
+      });
+      if (rowIdx !== -1) opts.diffHandle.value?.scrollToLine(rowIdx);
+    });
+  }
+
+  /**
+   * Dispatch a resolved PR-review action.
+   */
+  function dispatch(action: PrReviewAction) {
+    switch (action) {
+      case "next-hunk": goToHunk(1); break;
+      case "prev-hunk": goToHunk(-1); break;
+      case "next-file": goToFile(1); break;
+      case "prev-file": goToFile(-1); break;
+      case "comment-hunk": opts.diffHandle.value?.openComposeAtHunk(currentHunkIdx.value); break;
+      case "help": opts.onHelp(); break;
+      case "toggle-viewed":
+        if (opts.selectedDiffFile.value) opts.onToggleViewed(opts.selectedDiffFile.value);
+        break;
+      case "toggle-hide-viewed":
+        opts.hideViewed.value = !opts.hideViewed.value;
+        break;
+      case "submit-review":
+        if (!opts.submittingReview.value) opts.onSubmitReview();
+        break;
+      case "next-finding": jumpToFinding(1); break;
+      case "prev-finding": jumpToFinding(-1); break;
+    }
+  }
+
+  return { currentHunkIdx, currentFindingIdx, goToFile, goToHunk, jumpToFinding, dispatch };
+}
diff --git a/apps/desktop/src/composables/usePrReviewQueue.ts b/apps/desktop/src/composables/usePrReviewQueue.ts
new file mode 100644
index 00000000..a3e71643
--- /dev/null
+++ b/apps/desktop/src/composables/usePrReviewQueue.ts
@@ -0,0 +1,80 @@
+/**
+ * usePrReviewQueue.ts
+ *
+ * Bounded, cancellable, visibility-gated execution of the pre-review engine
+ * (C3, v3.6.0) over a PR's touched files. Concurrency is 1 by construction
+ * (a plain sequential `for`) — each `analyzeOne` call spawns a subprocess,
+ * so running several in parallel would fork N CLI processes at once.
+ *
+ * Visibility gating deliberately does NOT add its own `visibilitychange`
+ * listener — the host (`usePrPanel.ts`) already has one driving the 5-min
+ * poll; it calls this queue's `resume()` from that same handler instead of
+ * wiring a second listener (perf invariant: one listener, not two).
+ */
+import { ref } from "vue";
+import type { GitDiff } from "../utils/backend";
+import type { ReviewFinding } from "./usePrPreReview";
+
+export interface RunOptions {
+  onFinding: (finding: ReviewFinding) => void;
+  signal: AbortSignal;
+}
+
+export function usePrReviewQueue() {
+  const done = ref(0);
+  const total = ref(0);
+  const running = ref(false);
+
+  /** Resolvers waiting for `resume()` — one per file currently blocked on
+   *  `document.hidden`. Flushed (and cleared) by `resume()`. */
+  let resumeResolvers: Array<() => void> = [];
+
+  /** Wake every file paused on `document.hidden`. Safe to call even when
+   *  nothing is paused (empty flush). */
+  function resume(): void {
+    const resolvers = resumeResolvers;
+    resumeResolvers = [];
+    for (const r of resolvers) r();
+  }
+
+  function waitWhileHidden(signal: AbortSignal): Promise<void> {
+    if (!document.hidden || signal.aborted) return Promise.resolve();
+    return new Promise<void>((resolve) => {
+      resumeResolvers.push(resolve);
+      // An abort while paused must also unblock the wait — otherwise a PR
+      // switch during a hidden tab would leave the promise dangling forever.
+      signal.addEventListener("abort", () => resolve(), { once: true });
+    });
+  }
+
+  /**
+   * Sequentially analyze `files` via `analyzeOne`, streaming findings out
+   * through `onFinding` as each file completes. Bails immediately once
+   * `signal` aborts (PR switch / detail close), and pauses (without
+   * consuming CPU) whenever `document.hidden` is true.
+   */
+  async function run(
+    files: GitDiff[],
+    analyzeOne: (file: GitDiff) => Promise<ReviewFinding[]>,
+    opts: RunOptions,
+  ): Promise<void> {
+    running.value = true;
+    total.value = files.length;
+    done.value = 0;
+    try {
+      for (const file of files) {
+        if (opts.signal.aborted) return;
+        await waitWhileHidden(opts.signal);
+        if (opts.signal.aborted) return;
+        const findings = await analyzeOne(file);
+        if (opts.signal.aborted) return; // don't paint stale findings post-abort
+        for (const finding of findings) opts.onFinding(finding);
+        done.value++;
+      }
+    } finally {
+      running.value = false;
+    }
+  }
+
+  return { done, total, running, run, resume };
+}
diff --git a/apps/desktop/src/composables/usePrSummary.ts b/apps/desktop/src/composables/usePrSummary.ts
new file mode 100644
index 00000000..780494c9
--- /dev/null
+++ b/apps/desktop/src/composables/usePrSummary.ts
@@ -0,0 +1,112 @@
+/**
+ * usePrSummary.ts
+ *
+ * Opt-in AI PR summary (D1, v3.6.0) — one LLM pass over the PR's indexed
+ * diff (A1's per-file index, cheap — no full hunk parse needed for a
+ * summary) + commit titles, producing a short what/why/affected-areas
+ * block for the Info tab. Cached by `detailKey@headSha` (`usePrCache`).
+ */
+import { gitExec } from "../utils/backend";
+import { useAIProvider } from "./useAIProvider";
+import { localeToAiLanguage } from "./prAiLocale";
+
+function buildSystemPrompt(locale: string): string {
+  const lang = localeToAiLanguage(locale);
+  return `You write a short handoff summary for a pull request, for a
+reviewer who hasn't looked at the diff yet.
+
+You will receive the PR's commit titles and a per-file index (path +
+change counts) of everything it touches.
+
+Produce a concise summary in ${lang}, structured as three short sections:
+- What: what the PR does, in plain language.
+- Why: the motivation/intent, inferred from the commit titles and the
+  files touched (say so honestly if it's unclear from the data given).
+- Affected areas: the main directories/modules touched, grouped sensibly
+  (not a flat file list).
+
+Rules:
+- Plain prose with the three section labels ("What:", "Why:", "Affected
+  areas:"), no markdown headings, no code fences.
+- Be concrete — reference real file/module names from the data.
+- Never invent behavior not implied by the commit titles or file list.
+- Keep it under 6 sentences total.`;
+}
+
+export interface SummaryFileEntry {
+  path: string;
+  /** Raw per-file diff slice (from A1's `indexDiffFiles`) — used only for
+   *  a cheap add/delete line count, never the full hunk text (keeps the
+   *  prompt small for large PRs). */
+  raw: string;
+}
+
+function countChanges(raw: string): { additions: number; deletions: number } {
+  let additions = 0, deletions = 0;
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) additions++;
+    else if (line.startsWith("-")) deletions++;
+  }
+  return { additions, deletions };
+}
+
+export function buildSummaryPrompt(
+  files: SummaryFileEntry[],
+  commitTitles: string[],
+): string {
+  const parts: string[] = [];
+  parts.push("Commits:");
+  if (commitTitles.length) {
+    for (const title of commitTitles) parts.push(`- ${title}`);
+  } else {
+    parts.push("(no commit titles available)");
+  }
+  parts.push("");
+  parts.push("Files touched:");
+  for (const f of files) {
+    const { additions, deletions } = countChanges(f.raw);
+    parts.push(`- ${f.path} (+${additions}/-${deletions})`);
+  }
+  return parts.join("\n");
+}
+
+export interface GenerateSummaryContext {
+  cwd: string;
+  base: string;
+  head: string;
+  files: SummaryFileEntry[];
+  locale?: string;
+}
+
+/** Commit titles for the PR's range — best-effort, tries the plain branch
+ *  names first (works when the PR branches are fetched locally), falls
+ *  back to `origin/<base>..origin/<head>`, and finally gives up gracefully
+ *  (an empty list — the summary still generates from the file index alone). */
+async function commitTitlesForRange(cwd: string, base: string, head: string): Promise<string[]> {
+  if (!base || !head) return [];
+  for (const range of [`${base}..${head}`, `origin/${base}..origin/${head}`]) {
+    const res = await gitExec(cwd, ["log", "--format=%s", range]).catch(() => null);
+    if (res && res.exitCode === 0) {
+      const titles = (res.stdout ?? "").split("\n").map((l) => l.trim()).filter(Boolean);
+      if (titles.length) return titles;
+    }
+  }
+  return [];
+}
+
+export function usePrSummary() {
+  const ai = useAIProvider();
+
+  async function generate(ctx: GenerateSummaryContext): Promise<string> {
+    if (!ai.isAvailable.value) return "";
+    if (!ctx.files.length) return "";
+    const commitTitles = await commitTitlesForRange(ctx.cwd, ctx.base, ctx.head);
+    const systemPrompt = buildSystemPrompt(ctx.locale ?? "en");
+    const userPrompt = buildSummaryPrompt(ctx.files, commitTitles);
+    const raw = await ai.rawPrompt(systemPrompt, userPrompt).catch(() => "");
+    return raw.trim();
+  }
+
+  return { generate };
+}
diff --git a/apps/desktop/src/composables/useReviewIntelligence.ts b/apps/desktop/src/composables/useReviewIntelligence.ts
new file mode 100644
index 00000000..418f85df
--- /dev/null
+++ b/apps/desktop/src/composables/useReviewIntelligence.ts
@@ -0,0 +1,300 @@
+/**
+ * useReviewIntelligence.ts
+ *
+ * Unified AI + static Intelligence orchestrator (E2, v3.6.0) — composes the
+ * pre-review engine (C1/C3), the confidence/cap/dismissal filter (C2), the
+ * PR summary (D1), and the static heuristic flags (previously computed
+ * inline in `PrIntelligencePanel.vue`) behind one reactive surface and one
+ * merged `LineAnnotation` stream per file (E1).
+ *
+ * `usePrPanel.ts` **composes** this — it calls it once and re-exports its
+ * surface, it does not own this state itself ("compose, don't absorb").
+ */
+import { ref, computed, watch, type Ref } from "vue";
+import type { GitDiff, PullRequest, PullRequestDetail, CIAnnotation } from "../utils/backend";
+import type { LocaleKey } from "../locales";
+import { usePrCache, detailKey } from "./usePrCache";
+import { useSettings } from "./useSettings";
+import { useI18n } from "./useI18n";
+import { useAIProvider } from "./useAIProvider";
+import { usePrPreReview, type ReviewFinding } from "./usePrPreReview";
+import { usePrReviewQueue } from "./usePrReviewQueue";
+import { usePrSummary } from "./usePrSummary";
+import { filterFindings, normalizeFindingClass } from "./usePrFindingFilter";
+import { fromCIAnnotation, fromFinding, type LineAnnotation } from "./prAnnotations";
+import { parseFileDiff } from "./usePrPanel";
+
+export interface UseReviewIntelligenceOptions {
+  cwd: Ref<string>;
+  selectedPr: Ref<PullRequest | null>;
+  prDetail: Ref<PullRequestDetail | null>;
+  detailTab: Ref<string>;
+  /** Ensures `diffIndex` is populated (A1's per-file index — cheap; the
+   *  engine parses hunks itself from the raw slices, bypassing the UI's
+   *  lazy per-file parse without touching it). */
+  loadDiff: () => Promise<void>;
+  diffIndex: Ref<{ path: string; raw: string }[]>;
+  /** CI check-run annotations per file (v2.18), merged in as `source: "ci"`. */
+  annotationsByFile: Ref<Record<string, CIAnnotation[]>>;
+}
+
+// ─── Static heuristic flags (ported from PrIntelligencePanel.vue) ─────────
+
+/** Same detection thresholds as the pre-E2 inline `aiFlags` computed —
+ *  ported verbatim, just re-expressed as line-anchored `LineAnnotation`s
+ *  (`source: "static"`) instead of a bespoke `{file, reason, severity}`
+ *  shape, so they merge into the same overlay stream as CI/AI. */
+export function computeStaticFlags(
+  diffFiles: GitDiff[],
+  t: (key: LocaleKey, ...args: Array<string | number>) => string,
+): LineAnnotation[] {
+  const flags: LineAnnotation[] = [];
+  for (const diff of diffFiles) {
+    const firstLine = diff.hunks[0]?.lines.find((l) => l.type !== "delete")?.newLineNo
+      ?? diff.hunks[0]?.lines[0]?.oldLineNo
+      ?? 1;
+
+    const totalAdded = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === "add").length, 0);
+    const totalDeleted = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === "delete").length, 0);
+    if (totalAdded + totalDeleted > 200) {
+      flags.push({
+        source: "static", path: diff.path, line: firstLine, side: "RIGHT",
+        severity: "warning", title: t("pr.intel.flagBigFile", totalAdded + totalDeleted),
+      });
+    }
+
+    // Detect potential breaking changes: removed exports, deleted function
+    // signatures. Anchored to the specific deleted line (old side) when one
+    // matches, since unlike the other flags this one has a real anchor.
+    for (const hunk of diff.hunks) {
+      for (const line of hunk.lines) {
+        if (line.type !== "delete") continue;
+        if (/^\s*(export\s+(default|const|function|class)|module\.exports|def |pub fn |public )/.test(line.content)) {
+          flags.push({
+            source: "static", path: diff.path, line: line.oldLineNo ?? firstLine, side: "LEFT",
+            severity: "failure", title: t("pr.intel.flagExportRemoved"),
+          });
+        }
+      }
+    }
+
+    if (/\.(env|config|yaml|yml|toml|json|lock)$/.test(diff.path)) {
+      flags.push({
+        source: "static", path: diff.path, line: firstLine, side: "RIGHT",
+        severity: "notice", title: t("pr.intel.flagConfigChange"),
+      });
+    }
+
+    if (/migrat|schema\.sql|\.sql$/.test(diff.path.toLowerCase())) {
+      flags.push({
+        source: "static", path: diff.path, line: firstLine, side: "RIGHT",
+        severity: "warning", title: t("pr.intel.flagDbMigration"),
+      });
+    }
+
+    for (const hunk of diff.hunks) {
+      if (hunk.lines.length > 100) {
+        const anchor = hunk.lines.find((l) => l.type !== "delete")?.newLineNo ?? firstLine;
+        flags.push({
+          source: "static", path: diff.path, line: anchor, side: "RIGHT",
+          severity: "notice", title: t("pr.intel.flagBigHunk", hunk.lines.length),
+        });
+        break; // Only once per file, matching the pre-E2 behavior.
+      }
+    }
+  }
+  return flags;
+}
+
+export function useReviewIntelligence(opts: UseReviewIntelligenceOptions) {
+  const cache = usePrCache();
+  const { settings } = useSettings();
+  const { locale, t } = useI18n();
+  const ai = useAIProvider();
+  const preReview = usePrPreReview();
+  const reviewQueue = usePrReviewQueue();
+  const prSummaryEngine = usePrSummary();
+
+  // ─── AI pre-review pass (C1/C3) ──────────────────────────
+  const rawPreReviewFindings = ref<ReviewFinding[]>([]);
+  const dismissedFindingClasses = ref<Set<string>>(new Set());
+  const preReviewFindings = computed<ReviewFinding[]>(() =>
+    filterFindings(rawPreReviewFindings.value, {
+      threshold: settings.value.reviewAiConfidenceThreshold,
+      cap: settings.value.reviewAiMaxFindings,
+      dismissed: dismissedFindingClasses.value,
+    }),
+  );
+  const preReviewProgress = computed(() => ({ done: reviewQueue.done.value, total: reviewQueue.total.value }));
+  const preReviewRunning = reviewQueue.running;
+  let preReviewAbort: AbortController | null = null;
+
+  function stopPreReview() {
+    preReviewAbort?.abort();
+    preReviewAbort = null;
+  }
+
+  async function maybeRunPreReview() {
+    if (!settings.value.reviewAiPreReview || !ai.isAvailable.value) return;
+    const pr = opts.selectedPr.value;
+    const headSha = opts.prDetail.value?.headSha;
+    if (!pr || !headSha) return;
+
+    // Load dismissal memory before the cache lookup — `preReviewFindings`
+    // filters `rawPreReviewFindings` through `dismissedFindingClasses`, so
+    // this must be populated before either the cache-HIT return below or
+    // the cache-MISS pipeline run, or a dismissed finding reappears after
+    // restart whenever the cache already has findings at the current
+    // headSha (verifier fix, v3.6.0).
+    dismissedFindingClasses.value = cache.getDismissed(opts.cwd.value);
+
+    const key = `${detailKey(opts.cwd.value, pr.number)}@${headSha}`;
+    const cached = cache.getFindings(key);
+    if (cached) {
+      rawPreReviewFindings.value = cached;
+      return;
+    }
+
+    if (!opts.diffIndex.value.length) await opts.loadDiff();
+    const filesForReview = opts.diffIndex.value
+      .map((f) => parseFileDiff(f.raw))
+      .filter((f) => f.hunks.length > 0);
+    if (!filesForReview.length) return;
+
+    rawPreReviewFindings.value = [];
+    stopPreReview();
+    const controller = new AbortController();
+    preReviewAbort = controller;
+
+    await reviewQueue.run(
+      filesForReview,
+      (file) => preReview.analyzeFile(file, {
+        cwd: opts.cwd.value,
+        locale: locale.value,
+        otherDiffFiles: filesForReview,
+      }),
+      {
+        onFinding: (finding) => {
+          rawPreReviewFindings.value = [...rawPreReviewFindings.value, finding];
+        },
+        signal: controller.signal,
+      },
+    );
+
+    if (!controller.signal.aborted && opts.selectedPr.value?.number === pr.number) {
+      cache.setFindings(key, rawPreReviewFindings.value);
+    }
+  }
+
+  function dismissFinding(id: string) {
+    const finding = rawPreReviewFindings.value.find((f) => f.id === id);
+    if (!finding) return;
+    const cls = normalizeFindingClass(finding);
+    cache.addDismissed(opts.cwd.value, cls);
+    dismissedFindingClasses.value = new Set([...dismissedFindingClasses.value, cls]);
+  }
+
+  // ─── AI PR summary (D1) ───────────────────────────────────
+  const prSummary = ref<string>("");
+  const prSummaryLoading = ref(false);
+
+  async function loadSummary(force = false) {
+    if (!settings.value.reviewAiSummary || !ai.isAvailable.value) return;
+    const pr = opts.selectedPr.value;
+    const headSha = opts.prDetail.value?.headSha;
+    if (!pr || !headSha) return;
+    const key = `${detailKey(opts.cwd.value, pr.number)}@${headSha}`;
+    if (!force) {
+      const cached = cache.getSummary(key);
+      if (cached) {
+        prSummary.value = cached;
+        return;
+      }
+    }
+    if (!opts.diffIndex.value.length) await opts.loadDiff();
+    if (!opts.diffIndex.value.length) return;
+    prSummaryLoading.value = true;
+    try {
+      const text = await prSummaryEngine.generate({
+        cwd: opts.cwd.value,
+        base: opts.prDetail.value?.base ?? "",
+        head: opts.prDetail.value?.branch ?? "",
+        files: opts.diffIndex.value,
+        locale: locale.value,
+      });
+      if (opts.selectedPr.value?.number !== pr.number) return;
+      prSummary.value = text;
+      if (text) cache.setSummary(key, text);
+    } finally {
+      prSummaryLoading.value = false;
+    }
+  }
+
+  function regenerateSummary() {
+    return loadSummary(true);
+  }
+
+  // Trigger both passes whenever the selected PR's head SHA becomes known —
+  // a cache hit paints instantly, a miss starts the relevant engine. Firing
+  // on `headSha` (not `selectedPr`) means a re-push while the detail stays
+  // open re-triggers correctly too.
+  watch(() => opts.prDetail.value?.headSha, () => {
+    void maybeRunPreReview();
+    // The Info tab is the default on PR open — its own tab-change trigger
+    // (wired by the host) only fires on a *change*, so also cover the
+    // common case where the user never leaves Info.
+    if (opts.detailTab.value === "info") void loadSummary();
+  });
+
+  /** Called by the host on PR switch / detail close / cwd change. */
+  function reset() {
+    stopPreReview();
+    rawPreReviewFindings.value = [];
+    prSummary.value = "";
+  }
+
+  // ─── Merged LineAnnotation stream (E1/C4/E2) ─────────────
+  const lineAnnotationsByFile = computed<Record<string, LineAnnotation[]>>(() => {
+    const map: Record<string, LineAnnotation[]> = {};
+    for (const [path, anns] of Object.entries(opts.annotationsByFile.value)) {
+      map[path] = anns.map(fromCIAnnotation);
+    }
+    return map;
+  });
+
+  const staticFlags = computed<LineAnnotation[]>(() => {
+    // `diffIndex` slices carry raw text only — static flags need parsed
+    // hunks, same as the pre-review engine. Cheap (regex-based), fine to
+    // recompute per render; this composable doesn't touch the UI's lazy
+    // A1 shells.
+    const files = opts.diffIndex.value.map((f) => parseFileDiff(f.raw));
+    return computeStaticFlags(files, t);
+  });
+
+  /** The single stream `PrInlineDiff` renders per file: CI + AI findings +
+   *  static flags, merged. */
+  const mergedAnnotationsByFile = computed<Record<string, LineAnnotation[]>>(() => {
+    const map: Record<string, LineAnnotation[]> = {};
+    for (const [path, anns] of Object.entries(lineAnnotationsByFile.value)) {
+      map[path] = [...anns];
+    }
+    for (const finding of preReviewFindings.value) {
+      (map[finding.path] ??= []).push(fromFinding(finding));
+    }
+    for (const flag of staticFlags.value) {
+      (map[flag.path] ??= []).push(flag);
+    }
+    return map;
+  });
+
+  return {
+    preReviewFindings, preReviewProgress, preReviewRunning, dismissFinding,
+    prSummary, prSummaryLoading, loadSummary, regenerateSummary,
+    lineAnnotationsByFile, staticFlags, mergedAnnotationsByFile,
+    maybeRunPreReview, reset,
+    /** Resume the pre-review queue after a hidden→visible transition — the
+     *  host calls this from its existing `visibilitychange` handler rather
+     *  than this composable adding a second listener. */
+    resumePreReviewQueue: reviewQueue.resume,
+  };
+}
diff --git a/apps/desktop/src/composables/useSettings.ts b/apps/desktop/src/composables/useSettings.ts
index 6a342f7c..829a4312 100644
--- a/apps/desktop/src/composables/useSettings.ts
+++ b/apps/desktop/src/composables/useSettings.ts
@@ -158,6 +158,20 @@ export interface AppSettings {
   aiOllamaUrl: string;
   /** Ollama model name. */
   aiOllamaModel: string;
+  /**
+   * Review AI settings (E3, v3.6.0) — provider is inherited from the
+   * existing `aiProvider`/`aiEnabled` fields above; these four control the
+   * opt-in pre-review pass (C) and PR summary (D). All opt-in — false/off
+   * by default so the pipeline never runs unless the user turns it on.
+   */
+  /** Opt-in: run the local multi-hop pre-review pass when a PR is opened. */
+  reviewAiPreReview: boolean;
+  /** Confidence threshold (0-100) below which a finding is dropped. */
+  reviewAiConfidenceThreshold: number;
+  /** Top-N cap on findings shown per PR, by confidence descending. */
+  reviewAiMaxFindings: number;
+  /** Opt-in: generate a PR summary block on the Info tab. */
+  reviewAiSummary: boolean;
   /**
    * Last active tab in Today view — persisted between openings (v2.9).
    * After Phase 2 only "inbox" and "team" are live surfaces; legacy values
@@ -397,6 +411,10 @@ export const defaultAppSettings: AppSettings = {
   aiModelByProvider: {},
   aiOllamaUrl: "http://localhost:11434",
   aiOllamaModel: "codellama",
+  reviewAiPreReview: false,
+  reviewAiConfidenceThreshold: 60,
+  reviewAiMaxFindings: 15,
+  reviewAiSummary: false,
   launchpadActiveTab: "inbox",
   launchpadTeamTabEnabled: true,
   launchpadScopePaths: [],
diff --git a/apps/desktop/src/composables/useVirtualRows.ts b/apps/desktop/src/composables/useVirtualRows.ts
new file mode 100644
index 00000000..1ac53c1c
--- /dev/null
+++ b/apps/desktop/src/composables/useVirtualRows.ts
@@ -0,0 +1,64 @@
+/**
+ * useVirtualRows.ts
+ *
+ * Thin wrapper around `@tanstack/vue-virtual`'s `useVirtualizer`, generalizing
+ * the variable-height pattern already used in `CommitLog.vue` (measureElement
+ * + a post-declaration `setOptions` watch to avoid a TDZ error when `count`
+ * depends on values not yet initialized at the virtualizer's declaration
+ * site — see `CommitLog.vue:96-101,466-472`).
+ *
+ * Consumers own their own row model (`rows: T[]`); this composable only
+ * tracks `count` and exposes the virtualizer's items/size/measure helpers.
+ */
+import { computed, watch, type Ref } from "vue";
+import { useVirtualizer } from "@tanstack/vue-virtual";
+
+export interface UseVirtualRowsOptions {
+  /** Reactive row count — the virtualizer's `count` option is kept in sync. */
+  count: Ref<number>;
+  /** Returns the scrollable container element (or null before mount). */
+  getScrollElement: () => HTMLElement | null;
+  /** Estimated row height before DOM measurement corrects it. */
+  estimateSize: (index: number) => number;
+  /** Rows rendered outside the visible viewport on each side. Default 8. */
+  overscan?: number;
+}
+
+export function useVirtualRows(opts: UseVirtualRowsOptions) {
+  const virtualizer = useVirtualizer({
+    count: opts.count.value,
+    getScrollElement: opts.getScrollElement,
+    estimateSize: opts.estimateSize,
+    // Measure each item's actual DOM height after paint — rows of differing
+    // content (multi-line hunks, threads, critique panels) render at their
+    // real height instead of the fixed estimate.
+    measureElement: (el) => (el as HTMLElement).offsetHeight,
+    overscan: opts.overscan ?? 8,
+  });
+
+  // Sync `count` after this composable's other reactive dependencies are
+  // initialized in the caller — `{ immediate: true }` still fires once on
+  // setup, but since `opts.count` is passed in already-constructed (not
+  // computed lazily inside here), there is no TDZ risk the way there was
+  // for `rows.value.length` in CommitLog.vue's inline declaration.
+  watch(
+    opts.count,
+    (count) => {
+      virtualizer.value?.setOptions({
+        ...virtualizer.value.options,
+        count,
+      });
+    },
+    { immediate: true },
+  );
+
+  const virtualItems = computed(() => virtualizer.value?.getVirtualItems() ?? []);
+  const totalSize = computed(() => virtualizer.value?.getTotalSize() ?? 0);
+
+  /** Ref callback — attach to each rendered row's root element. */
+  function measure(el: Element | null) {
+    if (el) virtualizer.value?.measureElement(el);
+  }
+
+  return { virtualizer, virtualItems, totalSize, measure };
+}
diff --git a/apps/desktop/src/locales/en.ts b/apps/desktop/src/locales/en.ts
index 6fd4e56b..daa9b445 100644
--- a/apps/desktop/src/locales/en.ts
+++ b/apps/desktop/src/locales/en.ts
@@ -904,6 +904,26 @@ const en = {
       badge: "{0} annotation(s)",
       badgeTooltip: "View annotations in the diff",
     },
+    viewed: {
+      progress: "{0}/{1} viewed",
+      hide: "Hide viewed",
+      toggle: "Mark as viewed",
+    },
+    preReview: {
+      title: "Pre-review findings",
+      confidence: "Confidence",
+      dismiss: "Dismiss",
+      progress: "{0}/{1} files",
+      empty: "No findings.",
+      running: "Analyzing…",
+    },
+    summary: {
+      title: "Summary",
+      regenerate: "Regenerate",
+      copy: "Copy",
+      loading: "Generating summary…",
+      empty: "No summary yet.",
+    },
     comment: {
       edit: "Edit",
       delete: "Delete",
@@ -937,6 +957,13 @@ const en = {
       cancel: "Cancel",
       submitting: "Submitting\u2026",
     },
+    reviews: {
+      dismiss: "Dismiss",
+      dismissed: "Review dismissed",
+      requestReviewers: "Request",
+      requestReviewersPlaceholder: "username, username\u2026",
+      reviewersRequested: "Reviewers requested",
+    },
     intel: {
       conflictTitle: "Conflict Prediction",
       analyze: "Analyze",
@@ -1189,6 +1216,18 @@ const en = {
         formRulesPlaceholder: "e.g., Focus on security fixes, group by backend/frontend, use English...",
       },
     },
+    reviewAi: {
+      title: "Review AI",
+      hint: "Local, opt-in AI pass over PR diffs — pre-review findings + summary.",
+      preReview: "Pre-review findings",
+      preReviewHint: "Analyze each file in the background when a PR is opened (opt-in, local-first).",
+      threshold: "Confidence threshold",
+      thresholdHint: "Findings below this confidence are hidden.",
+      cap: "Max findings per PR",
+      capHint: "Top-N findings shown, sorted by confidence.",
+      summary: "PR summary",
+      summaryHint: "Generate a what/why/affected-areas summary on the Info tab.",
+    },
     language: "Interface language",
     languageAuto: "Automatic (system)",
     commitMessageLang: "Commit message language",
@@ -2223,6 +2262,17 @@ const en = {
       redoMerge: "Redo (merge editor)",
       saveAll: "Save all files (merge editor)",
       closeOverlay: "Close overlay",
+      prNextHunk: "Next hunk (PR review)",
+      prPrevHunk: "Previous hunk (PR review)",
+      prNextFile: "Next file (PR review)",
+      prPrevFile: "Previous file (PR review)",
+      prToggleViewed: "Mark file as viewed",
+      prHideViewed: "Hide viewed files",
+      prFilterFiles: "Filter files",
+      prCommentHunk: "Comment on current hunk",
+      prNextFinding: "Next AI finding",
+      prPrevFinding: "Previous AI finding",
+      prSubmitReview: "Submit review",
     },
     gitWorkflow: {
       title: "Git workflow",
diff --git a/apps/desktop/src/locales/es.ts b/apps/desktop/src/locales/es.ts
index 47ebe460..44979fd8 100644
--- a/apps/desktop/src/locales/es.ts
+++ b/apps/desktop/src/locales/es.ts
@@ -888,6 +888,26 @@ const es: Locale = {
       badge: "{0} anotación(es)",
       badgeTooltip: "Ver las anotaciones en el diff",
     },
+    viewed: {
+      progress: "{0}/{1} vistos",
+      hide: "Ocultar vistos",
+      toggle: "Marcar como visto",
+    },
+    preReview: {
+      title: "Hallazgos de pre-revisión",
+      confidence: "Confianza",
+      dismiss: "Descartar",
+      progress: "{0}/{1} archivos",
+      empty: "Sin hallazgos.",
+      running: "Analizando…",
+    },
+    summary: {
+      title: "Resumen",
+      regenerate: "Regenerar",
+      copy: "Copiar",
+      loading: "Generando resumen…",
+      empty: "Aún no hay resumen.",
+    },
     comment: {
       edit: "Editar",
       delete: "Eliminar",
@@ -921,6 +941,13 @@ const es: Locale = {
       cancel: "Cancelar",
       submitting: "Enviando…",
     },
+    reviews: {
+      dismiss: "Descartar",
+      dismissed: "Review descartada",
+      requestReviewers: "Solicitar",
+      requestReviewersPlaceholder: "usuario, usuario…",
+      reviewersRequested: "Revisores solicitados",
+    },
     intel: {
       conflictTitle: "Conflict Prediction",
       analyze: "Analizar",
@@ -1164,6 +1191,18 @@ const es: Locale = {
         formRulesPlaceholder: "p. ej., Centrarse en correcciones de seguridad, agrupar por backend/frontend, usar español...",
       },
     },
+    reviewAi: {
+      title: "Review AI",
+      hint: "Pase de IA local y opt-in sobre los diffs de PR — hallazgos de pre-revisión + resumen.",
+      preReview: "Hallazgos de pre-revisión",
+      preReviewHint: "Analizar cada archivo en segundo plano al abrir una PR (opt-in, local primero).",
+      threshold: "Umbral de confianza",
+      thresholdHint: "Los hallazgos por debajo de este umbral se ocultan.",
+      cap: "Máximo de hallazgos por PR",
+      capHint: "Top-N hallazgos mostrados, ordenados por confianza.",
+      summary: "Resumen de PR",
+      summaryHint: "Generar un resumen qué/por qué/áreas afectadas en la pestaña Info.",
+    },
     language: "Idioma de la interfaz",
     languageAuto: "Automático (sistema)",
     commitMessageLang: "Idioma de los mensajes de commit",
@@ -2182,6 +2221,17 @@ const es: Locale = {
       redoMerge: "Rehacer (editor de conflictos)",
       saveAll: "Guardar todos (editor de conflictos)",
       closeOverlay: "Cerrar overlay",
+      prNextHunk: "Bloque siguiente (revisión de PR)",
+      prPrevHunk: "Bloque anterior (revisión de PR)",
+      prNextFile: "Archivo siguiente (revisión de PR)",
+      prPrevFile: "Archivo anterior (revisión de PR)",
+      prToggleViewed: "Marcar archivo como visto",
+      prHideViewed: "Ocultar archivos vistos",
+      prFilterFiles: "Filtrar archivos",
+      prCommentHunk: "Comentar el bloque actual",
+      prNextFinding: "Siguiente hallazgo de IA",
+      prPrevFinding: "Hallazgo de IA anterior",
+      prSubmitReview: "Enviar revisión",
     },
     gitWorkflow: {
       title: "Flujo de trabajo Git",
diff --git a/apps/desktop/src/locales/fr.ts b/apps/desktop/src/locales/fr.ts
index a6fbb009..6c637bc0 100644
--- a/apps/desktop/src/locales/fr.ts
+++ b/apps/desktop/src/locales/fr.ts
@@ -897,6 +897,26 @@ const fr: Locale = {
       badge: "{0} annotation(s)",
       badgeTooltip: "Voir les annotations dans le diff",
     },
+    viewed: {
+      progress: "{0}/{1} vus",
+      hide: "Masquer les vus",
+      toggle: "Marquer comme vu",
+    },
+    preReview: {
+      title: "Constats de pré-review",
+      confidence: "Confiance",
+      dismiss: "Ignorer",
+      progress: "{0}/{1} fichiers",
+      empty: "Aucun constat.",
+      running: "Analyse en cours…",
+    },
+    summary: {
+      title: "Résumé",
+      regenerate: "Régénérer",
+      copy: "Copier",
+      loading: "Génération du résumé…",
+      empty: "Pas encore de résumé.",
+    },
     comment: {
       edit: "Modifier",
       delete: "Supprimer",
@@ -930,6 +950,13 @@ const fr: Locale = {
       cancel: "Annuler",
       submitting: "Envoi\u2026",
     },
+    reviews: {
+      dismiss: "Ignorer",
+      dismissed: "Review ignor\u00e9e",
+      requestReviewers: "Demander",
+      requestReviewersPlaceholder: "nom d'utilisateur, nom d'utilisateur\u2026",
+      reviewersRequested: "Reviewers demand\u00e9s",
+    },
     intel: {
       conflictTitle: "Conflict Prediction",
       analyze: "Analyser",
@@ -1173,6 +1200,18 @@ const fr: Locale = {
         formRulesPlaceholder: "Ex. : Se concentrer sur les correctifs de sécurité, regrouper par backend/frontend, utiliser le français...",
       },
     },
+    reviewAi: {
+      title: "Review AI",
+      hint: "Passe IA locale et opt-in sur les diffs de PR — constats de pré-review + résumé.",
+      preReview: "Constats de pré-review",
+      preReviewHint: "Analyser chaque fichier en arrière-plan à l'ouverture d'une PR (opt-in, local d'abord).",
+      threshold: "Seuil de confiance",
+      thresholdHint: "Les constats sous ce seuil de confiance sont masqués.",
+      cap: "Constats max par PR",
+      capHint: "Top-N constats affichés, triés par confiance.",
+      summary: "Résumé de PR",
+      summaryHint: "Générer un résumé quoi/pourquoi/zones affectées dans l'onglet Info.",
+    },
     language: "Langue de l\u2019interface",
     languageAuto: "Automatique (syst\u00e8me)",
     commitMessageLang: "Langue des messages de commit",
@@ -2192,6 +2231,17 @@ const fr: Locale = {
       redoMerge: "Rétablir (éditeur de conflits)",
       saveAll: "Sauvegarder tous les fichiers (éditeur de conflits)",
       closeOverlay: "Fermer l'overlay",
+      prNextHunk: "Bloc suivant (revue de PR)",
+      prPrevHunk: "Bloc précédent (revue de PR)",
+      prNextFile: "Fichier suivant (revue de PR)",
+      prPrevFile: "Fichier précédent (revue de PR)",
+      prToggleViewed: "Marquer le fichier comme vu",
+      prHideViewed: "Masquer les fichiers vus",
+      prFilterFiles: "Filtrer les fichiers",
+      prCommentHunk: "Commenter le bloc courant",
+      prNextFinding: "Constat IA suivant",
+      prPrevFinding: "Constat IA précédent",
+      prSubmitReview: "Envoyer la revue",
     },
     gitWorkflow: {
       title: "Workflow Git",
diff --git a/apps/desktop/src/locales/pt-BR.ts b/apps/desktop/src/locales/pt-BR.ts
index 895827d7..fa99898c 100644
--- a/apps/desktop/src/locales/pt-BR.ts
+++ b/apps/desktop/src/locales/pt-BR.ts
@@ -889,6 +889,26 @@ const ptBR: Locale = {
       badge: "{0} anotação(ões)",
       badgeTooltip: "Ver as anotações no diff",
     },
+    viewed: {
+      progress: "{0}/{1} vistos",
+      hide: "Ocultar vistos",
+      toggle: "Marcar como visto",
+    },
+    preReview: {
+      title: "Achados de pré-review",
+      confidence: "Confiança",
+      dismiss: "Descartar",
+      progress: "{0}/{1} arquivos",
+      empty: "Nenhum achado.",
+      running: "Analisando…",
+    },
+    summary: {
+      title: "Resumo",
+      regenerate: "Regenerar",
+      copy: "Copiar",
+      loading: "Gerando resumo…",
+      empty: "Ainda sem resumo.",
+    },
     comment: {
       edit: "Editar",
       delete: "Excluir",
@@ -922,6 +942,13 @@ const ptBR: Locale = {
       cancel: "Cancelar",
       submitting: "Enviando…",
     },
+    reviews: {
+      dismiss: "Descartar",
+      dismissed: "Review descartada",
+      requestReviewers: "Solicitar",
+      requestReviewersPlaceholder: "usuário, usuário…",
+      reviewersRequested: "Revisores solicitados",
+    },
     intel: {
       conflictTitle: "Conflict Prediction",
       analyze: "Analisar",
@@ -1165,6 +1192,18 @@ const ptBR: Locale = {
         formRulesPlaceholder: "ex: Focar em correções de segurança, agrupar por backend/frontend, usar português...",
       },
     },
+    reviewAi: {
+      title: "Review AI",
+      hint: "Passagem de IA local e opt-in sobre os diffs da PR — achados de pré-review + resumo.",
+      preReview: "Achados de pré-review",
+      preReviewHint: "Analisar cada arquivo em segundo plano ao abrir uma PR (opt-in, local primeiro).",
+      threshold: "Limite de confiança",
+      thresholdHint: "Achados abaixo deste limite de confiança são ocultados.",
+      cap: "Máximo de achados por PR",
+      capHint: "Top-N achados exibidos, ordenados por confiança.",
+      summary: "Resumo de PR",
+      summaryHint: "Gerar um resumo o quê/por quê/áreas afetadas na aba Info.",
+    },
     language: "Idioma da interface",
     languageAuto: "Automático (sistema)",
     commitMessageLang: "Idioma das mensagens de commit",
@@ -2182,6 +2221,17 @@ const ptBR: Locale = {
       redoMerge: "Refazer (editor de conflitos)",
       saveAll: "Salvar todos (editor de conflitos)",
       closeOverlay: "Fechar overlay",
+      prNextHunk: "Próximo bloco (revisão de PR)",
+      prPrevHunk: "Bloco anterior (revisão de PR)",
+      prNextFile: "Próximo arquivo (revisão de PR)",
+      prPrevFile: "Arquivo anterior (revisão de PR)",
+      prToggleViewed: "Marcar arquivo como visto",
+      prHideViewed: "Ocultar arquivos vistos",
+      prFilterFiles: "Filtrar arquivos",
+      prCommentHunk: "Comentar o bloco atual",
+      prNextFinding: "Próximo achado da IA",
+      prPrevFinding: "Achado da IA anterior",
+      prSubmitReview: "Enviar revisão",
     },
     gitWorkflow: {
       title: "Fluxo de trabalho Git",
diff --git a/apps/desktop/src/locales/zh-CN.ts b/apps/desktop/src/locales/zh-CN.ts
index 9b5c4455..12c4e4fa 100644
--- a/apps/desktop/src/locales/zh-CN.ts
+++ b/apps/desktop/src/locales/zh-CN.ts
@@ -877,6 +877,26 @@ const zhCN: Locale = {
       badge: "{0} 条注释",
       badgeTooltip: "在 diff 中查看注释",
     },
+    viewed: {
+      progress: "已查看 {0}/{1}",
+      hide: "隐藏已查看",
+      toggle: "标记为已查看",
+    },
+    preReview: {
+      title: "预审查发现项",
+      confidence: "置信度",
+      dismiss: "驳回",
+      progress: "{0}/{1} 个文件",
+      empty: "暂无发现项。",
+      running: "分析中…",
+    },
+    summary: {
+      title: "摘要",
+      regenerate: "重新生成",
+      copy: "复制",
+      loading: "正在生成摘要…",
+      empty: "暂无摘要。",
+    },
     comment: {
       edit: "编辑",
       delete: "删除",
@@ -910,6 +930,13 @@ const zhCN: Locale = {
       cancel: "取消",
       submitting: "提交中…",
     },
+    reviews: {
+      dismiss: "驳回",
+      dismissed: "已驳回该 review",
+      requestReviewers: "请求",
+      requestReviewersPlaceholder: "用户名，用户名…",
+      reviewersRequested: "已请求审阅者",
+    },
     intel: {
       conflictTitle: "Conflict Prediction",
       analyze: "分析",
@@ -1223,6 +1250,18 @@ const zhCN: Locale = {
         formRulesPlaceholder: "例如，关注安全修复，按前端/后端分组，使用中文...",
       },
     },
+    reviewAi: {
+      title: "Review AI",
+      hint: "本地、可选启用的 AI 分析，针对 PR 差异 —— 预审查发现项 + 摘要。",
+      preReview: "预审查发现项",
+      preReviewHint: "打开 PR 时在后台分析每个文件（可选启用，本地优先）。",
+      threshold: "置信度阈值",
+      thresholdHint: "低于此置信度的发现项将被隐藏。",
+      cap: "每个 PR 的最大发现项数",
+      capHint: "按置信度排序显示前 N 项发现。",
+      summary: "PR 摘要",
+      summaryHint: "在信息标签页生成内容/原因/受影响范围摘要。",
+    },
     language: "界面语言",
     languageAuto: "自动（跟随系统）",
     commitMessageLang: "提交信息语言",
@@ -2167,6 +2206,17 @@ const zhCN: Locale = {
       redoMerge: "重做（冲突编辑器）",
       saveAll: "保存全部（冲突编辑器）",
       closeOverlay: "关闭浮层",
+      prNextHunk: "下一个代码块（PR 审查）",
+      prPrevHunk: "上一个代码块（PR 审查）",
+      prNextFile: "下一个文件（PR 审查）",
+      prPrevFile: "上一个文件（PR 审查）",
+      prToggleViewed: "标记文件为已查看",
+      prHideViewed: "隐藏已查看的文件",
+      prFilterFiles: "筛选文件",
+      prCommentHunk: "评论当前代码块",
+      prNextFinding: "下一个 AI 发现项",
+      prPrevFinding: "上一个 AI 发现项",
+      prSubmitReview: "提交审查",
     },
     gitWorkflow: {
       title: "Git 工作流",
diff --git a/apps/desktop/src/utils/__tests__/backend-pr-headsha.test.ts b/apps/desktop/src/utils/__tests__/backend-pr-headsha.test.ts
new file mode 100644
index 00000000..055541ef
--- /dev/null
+++ b/apps/desktop/src/utils/__tests__/backend-pr-headsha.test.ts
@@ -0,0 +1,78 @@
+/**
+ * `PullRequestDetail.headSha` mapping (Task 0, v3.6.0) — viewed-state
+ * invalidation (B2) and AI findings/summary caching (C3/D1) key off this
+ * field, so a missing/renamed backend field must fail loudly here rather
+ * than silently degrade to `""` everywhere.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const devFetch = vi.fn();
+const tauriInvoke = vi.fn();
+let tauri = false;
+
+vi.mock("../backend-core", () => ({
+  isTauri: () => tauri,
+  devFetch: (...args: unknown[]) => devFetch(...args),
+  tauriInvoke: (...args: unknown[]) => tauriInvoke(...args),
+  DEV_SERVER: "http://localhost:3001",
+}));
+
+function mockRes(json: unknown) {
+  return { ok: true, status: 200, text: async () => "", json: async () => json };
+}
+
+const RAW_DETAIL = {
+  number: 42,
+  title: "t",
+  body: "b",
+  state: "open",
+  author: "alice",
+  branch: "feat",
+  base: "main",
+  draft: false,
+  created_at: "2026-01-01",
+  updated_at: "2026-01-02",
+  merged_at: "",
+  url: "https://example.com/42",
+  additions: 1,
+  deletions: 1,
+  changed_files: 1,
+  comments: 0,
+  review_comments: 0,
+  labels: [],
+  reviewers: [],
+  mergeable: "MERGEABLE",
+  checks_status: "success",
+  can_merge: true,
+};
+
+describe("ghPrDetail — headSha mapping", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    devFetch.mockReset();
+    tauriInvoke.mockReset();
+    tauri = false;
+  });
+
+  it("maps dev-server head_sha to headSha", async () => {
+    devFetch.mockResolvedValue(mockRes({ ...RAW_DETAIL, head_sha: "abc123" }));
+    const { ghPrDetail } = await import("../backend-pr");
+    const detail = await ghPrDetail("/repo", 42);
+    expect(detail.headSha).toBe("abc123");
+  });
+
+  it("falls back to empty string when head_sha is missing", async () => {
+    devFetch.mockResolvedValue(mockRes({ ...RAW_DETAIL }));
+    const { ghPrDetail } = await import("../backend-pr");
+    const detail = await ghPrDetail("/repo", 42);
+    expect(detail.headSha).toBe("");
+  });
+
+  it("maps the Tauri head_sha the same way", async () => {
+    tauri = true;
+    tauriInvoke.mockResolvedValue({ ...RAW_DETAIL, head_sha: "def456" });
+    const { ghPrDetail } = await import("../backend-pr");
+    const detail = await ghPrDetail("/repo", 42);
+    expect(detail.headSha).toBe("def456");
+  });
+});
diff --git a/apps/desktop/src/utils/__tests__/backend-pr-review-admin.test.ts b/apps/desktop/src/utils/__tests__/backend-pr-review-admin.test.ts
new file mode 100644
index 00000000..41bb651a
--- /dev/null
+++ b/apps/desktop/src/utils/__tests__/backend-pr-review-admin.test.ts
@@ -0,0 +1,63 @@
+/**
+ * Task B4 (v3.6.0) — `ghDismissReview`/`ghRequestReviewers` dev-server
+ * wrapper shape (parity with the Rust Tauri commands).
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const devFetch = vi.fn();
+const tauriInvoke = vi.fn();
+let tauri = false;
+
+vi.mock("../backend-core", () => ({
+  isTauri: () => tauri,
+  devFetch: (...args: unknown[]) => devFetch(...args),
+  tauriInvoke: (...args: unknown[]) => tauriInvoke(...args),
+  DEV_SERVER: "http://localhost:3001",
+}));
+
+function mockRes(opts: { ok: boolean; json?: unknown }) {
+  return { ok: opts.ok, status: opts.ok ? 200 : 500, json: async () => opts.json ?? {} };
+}
+
+describe("ghDismissReview / ghRequestReviewers", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    devFetch.mockReset();
+    tauriInvoke.mockReset();
+    tauri = false;
+  });
+
+  it("ghDismissReview posts to the dev-server route with { ok: true }", async () => {
+    devFetch.mockResolvedValue(mockRes({ ok: true, json: { ok: true } }));
+    const { ghDismissReview } = await import("../backend-pr");
+    await expect(ghDismissReview("/repo", 1, 7, "resolved")).resolves.toBeUndefined();
+    expect(devFetch).toHaveBeenCalledWith(
+      "http://localhost:3001/api/gh-dismiss-review",
+      expect.objectContaining({ method: "POST" }),
+    );
+  });
+
+  it("ghDismissReview surfaces the server error", async () => {
+    devFetch.mockResolvedValue(mockRes({ ok: false, json: { error: "not found" } }));
+    const { ghDismissReview } = await import("../backend-pr");
+    await expect(ghDismissReview("/repo", 1, 7)).rejects.toThrow(/not found/);
+  });
+
+  it("ghRequestReviewers posts logins to the dev-server route", async () => {
+    devFetch.mockResolvedValue(mockRes({ ok: true, json: { ok: true } }));
+    const { ghRequestReviewers } = await import("../backend-pr");
+    await expect(ghRequestReviewers("/repo", 1, ["alice"])).resolves.toBeUndefined();
+    const [, init] = devFetch.mock.calls[0];
+    expect(JSON.parse(init.body)).toEqual({ cwd: "/repo", number: 1, logins: ["alice"] });
+  });
+
+  it("ghDismissReview routes through tauriInvoke in Tauri", async () => {
+    tauri = true;
+    tauriInvoke.mockResolvedValue(undefined);
+    const { ghDismissReview } = await import("../backend-pr");
+    await ghDismissReview("/repo", 1, 7, "msg");
+    expect(tauriInvoke).toHaveBeenCalledWith("gh_dismiss_review", {
+      cwd: "/repo", number: 1, reviewId: 7, message: "msg",
+    });
+  });
+});
diff --git a/apps/desktop/src/utils/backend-gitlab.ts b/apps/desktop/src/utils/backend-gitlab.ts
index 440d47e4..c5b736a8 100644
--- a/apps/desktop/src/utils/backend-gitlab.ts
+++ b/apps/desktop/src/utils/backend-gitlab.ts
@@ -58,7 +58,7 @@ export async function glGetMr(cwd: string, iid: number): Promise<PullRequestDeta
     merged_at: string; url: string; additions: number; deletions: number;
     changed_files: number; comments: number; review_comments: number;
     labels: string[]; reviewers: string[]; mergeable: string; checks_status: string;
-    can_merge: boolean | null;
+    can_merge: boolean | null; head_sha?: string;
   }>("gl_get_mr", { cwd, iid });
   return {
     number: raw.number, title: raw.title, body: raw.body, state: raw.state,
@@ -68,10 +68,24 @@ export async function glGetMr(cwd: string, iid: number): Promise<PullRequestDeta
     changedFiles: raw.changed_files, comments: raw.comments,
     reviewComments: raw.review_comments, labels: raw.labels, reviewers: raw.reviewers,
     mergeable: raw.mergeable, checksStatus: raw.checks_status,
-    canMerge: raw.can_merge ?? null,
+    canMerge: raw.can_merge ?? null, headSha: raw.head_sha ?? "",
   } as unknown as PullRequestDetail;
 }
 
+/** GitLab MR diff refs (F1, v3.6.0) — the three SHAs the Discussions API
+ *  needs to correctly anchor an inline comment. */
+export interface MrDiffRefs {
+  baseSha: string;
+  startSha: string;
+  headSha: string;
+}
+
+/** Get a MR's diff refs. Tauri-only, like all GitLab commands. */
+export async function glMrDiffRefs(cwd: string, iid: number): Promise<MrDiffRefs> {
+  if (!isTauri()) throw new Error("glMrDiffRefs requires Tauri");
+  return tauriInvoke<MrDiffRefs>("gl_mr_diff_refs", { cwd, iid });
+}
+
 /** Get the unified diff of a MR. */
 export async function glMrDiff(cwd: string, iid: number): Promise<string> {
   if (!isTauri()) throw new Error("glMrDiff requires Tauri");
@@ -236,6 +250,13 @@ export async function glReviewerCandidates(cwd: string): Promise<ReviewerCandida
   return tauriInvoke<ReviewerCandidate[]>("gl_reviewer_candidates", { cwd });
 }
 
+/** Request reviewers on an existing MR (B4, v3.6.0) — usernames resolved to
+ *  numeric GitLab member ids on the Rust side. */
+export async function glRequestReviewers(cwd: string, iid: number, usernames: string[]): Promise<void> {
+  if (!isTauri()) throw new Error("glRequestReviewers requires Tauri");
+  await tauriInvoke("gl_request_reviewers", { cwd, iid, usernames });
+}
+
 export async function glBranches(cwd: string): Promise<string[]> {
   if (!isTauri()) return [];
   return tauriInvoke<string[]>("gl_branches", { cwd });
diff --git a/apps/desktop/src/utils/backend-pr.ts b/apps/desktop/src/utils/backend-pr.ts
index 270ed47c..5b80c997 100644
--- a/apps/desktop/src/utils/backend-pr.ts
+++ b/apps/desktop/src/utils/backend-pr.ts
@@ -447,6 +447,45 @@ export async function ghPrReady(cwd: string, number: number): Promise<void> {
   return tauriInvoke<void>("gh_pr_ready", { cwd, number });
 }
 
+/** Dismiss a submitted review (B4, v3.6.0). */
+export async function ghDismissReview(
+  cwd: string,
+  number: number,
+  reviewId: number,
+  message: string = "",
+): Promise<void> {
+  if (isTauri()) {
+    await tauriInvoke("gh_dismiss_review", { cwd, number, reviewId, message });
+    return;
+  }
+  const resp = await devFetch(`${DEV_SERVER}/api/gh-dismiss-review`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ cwd, number, reviewId, message }),
+  });
+  const data = await resp.json().catch(() => ({}));
+  if (!resp.ok || data.error) throw new Error(data.error || `gh dismiss review failed: ${resp.status}`);
+}
+
+/** Request reviewers on an existing PR (B4, v3.6.0). */
+export async function ghRequestReviewers(
+  cwd: string,
+  number: number,
+  logins: string[],
+): Promise<void> {
+  if (isTauri()) {
+    await tauriInvoke("gh_request_reviewers", { cwd, number, logins });
+    return;
+  }
+  const resp = await devFetch(`${DEV_SERVER}/api/gh-request-reviewers`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ cwd, number, logins }),
+  });
+  const data = await resp.json().catch(() => ({}));
+  if (!resp.ok || data.error) throw new Error(data.error || `gh request reviewers failed: ${resp.status}`);
+}
+
 // ─── PR Detail, Diff & Checks (Phase 9.1) ──────────────────
 
 export interface PullRequestDetail {
@@ -477,6 +516,12 @@ export interface PullRequestDetail {
    * and gate the merge button on errors only, never on an unknown permission.
    */
   canMerge: boolean | null;
+  /**
+   * The PR's current head commit SHA. Empty string when a forge can't
+   * cheaply provide one — callers must treat `""` as "no head SHA known"
+   * and skip head-keyed invalidation/caching gracefully (v3.6.0).
+   */
+  headSha: string;
 }
 
 export interface CICheck {
@@ -568,6 +613,7 @@ export async function ghPrDetail(cwd: string, number: number): Promise<PullReque
       mergeable: string;
       checks_status: string;
       can_merge: boolean | null;
+      head_sha?: string;
     }>("gh_pr_detail", { cwd, number });
     return {
       number: raw.number,
@@ -592,6 +638,7 @@ export async function ghPrDetail(cwd: string, number: number): Promise<PullReque
       mergeable: raw.mergeable,
       checksStatus: raw.checks_status,
       canMerge: raw.can_merge ?? null,
+      headSha: raw.head_sha ?? "",
     };
   }
   // Browser dev mode
@@ -607,6 +654,7 @@ export async function ghPrDetail(cwd: string, number: number): Promise<PullReque
     changedFiles: raw.changed_files, comments: raw.comments, reviewComments: raw.review_comments,
     labels: raw.labels, reviewers: raw.reviewers, mergeable: raw.mergeable, checksStatus: raw.checks_status,
     canMerge: raw.can_merge ?? null,
+    headSha: raw.head_sha ?? "",
   };
 }
 
@@ -1160,6 +1208,7 @@ export async function azPrDetail(cwd: string, number: number): Promise<PullReque
       mergeable: raw.mergeable,
       checksStatus: raw.checks_status,
       canMerge: raw.can_merge ?? null,
+      headSha: raw.head_sha ?? "",
     };
   }
   throw new Error(AZURE_WEB_ONLY);
diff --git a/docs/superpowers/plans/2026-07-09-v3.6.0-pr-review-2.md b/docs/superpowers/plans/2026-07-09-v3.6.0-pr-review-2.md
new file mode 100644
index 00000000..f4f57a44
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-09-v3.6.0-pr-review-2.md
@@ -0,0 +1,1095 @@
+# v3.6.0 — PR Review 2.0 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: use `superpowers:subagent-driven-development`
+> (recommended) or `superpowers:executing-plans` to implement this plan task-by-task.
+> Steps use checkbox (`- [ ]`) syntax for tracking. Work the tasks **in order** — later
+> tasks depend on types/composables introduced earlier. Every task ends with a named
+> conventional commit; the branch must stay green (`pnpm -r test` + `cd apps/desktop &&
+> pnpm test`) after each commit.
+
+**Branch:** `feat/pr-review-2` (already created, up to date on `main`).
+
+**Spec (read in full first):** `docs/superpowers/specs/2026-07-09-v3.6.0-pr-review-2-target-ux.md`.
+This plan implements workstreams A–F of that spec. Section numbers below (A1, B2, …) map 1:1
+to the spec. Do not re-decide anything the spec already fixed.
+
+---
+
+## Goal
+
+Rebuild the in-app PR review around three axes:
+1. **Performance** — lazy per-file diff parse, line virtualization, 6→3 network calls on
+   the hot path.
+2. **Review flow** — GitHub-standard keymap, viewed-file state, pending-review surfacing,
+   dismiss/request-reviewers.
+3. **AI** — a local-first, opt-in, confidence-scored pre-review pass + PR summary, unified
+   with the existing hunk critique and static flags into one `useReviewIntelligence`
+   composable behind one settings surface.
+Plus: complete the GitLab review methods (largest stub gap).
+
+## Architecture at a glance
+
+- The AI pipeline lives **entirely in `apps/desktop`** (composables). `packages/core` gains
+  only one pure, browser-safe helper (`extractImportSources`) consumed by the dependency hop.
+- No new Tauri command is needed for the AI pipeline: it reuses `getGitBlame`
+  (`backend.ts:1118`), `gitExec`, `getPRDiff`, and `useAIProvider.rawPrompt`
+  (`useAIProvider.ts:537`). One new command **is** needed for GitLab F1 (`gl_mr_diff_refs`).
+- SWR persistence (`usePrCache.ts`) is extended incrementally for viewed-state (B2), draft
+  review (B3), and AI findings/summary keyed by `repo#number@headSha` (C3/D1).
+- Keyboard handling is a **pure resolver** (`resolvePrReviewShortcut`) unit-tested in
+  isolation (pattern: `resolveTerminalShortcut`, `useTerminalSessions.ts:12-20`), wired by a
+  thin listener scoped to the Diff tab in `PrDetailView.vue`. It must not collide with the
+  two existing global handlers in `App.vue` (`onGlobalKeydown` @ `App.vue:2476` handles
+  `⌘⇧L` + `Escape`; `onKeyDown` @ `App.vue:2622`).
+
+## Global constraints (spec §4 — enforce in every task)
+
+- **IPC**: every new `#[tauri::command]` gets a typed wrapper in `apps/desktop/src/utils/backend*.ts`
+  **and** a `dev-server.mjs` route in the same commit. Never `invoke()` outside `backend*.ts`.
+  (Task 0 and F1 are the only tasks adding/altering commands.)
+- **Parity**: deterministic new commands get parity coverage; the dev-server route must return
+  the same shape as Rust. Run `pnpm test:parity` after Task 0 and F1.
+- **i18n**: every user-visible string gets a key in **all 5** locales (`en.ts`, `fr.ts`,
+  `es.ts`, `pt-br.ts`, `zh-cn.ts` — exact filenames). Add keys in the same commit as the UI
+  that uses them; Task G is a final sweep/verification, not a substitute.
+- **Settings sync**: any new field goes in **both** `useSettings.ts` (`AppSettings` +
+  `DEFAULT_SETTINGS`) and `SettingsPanel.vue` (local `Settings` + default) in the same commit.
+- **Sanitize**: any LLM/user-derived HTML goes through `useSafeHtml.ts` (never the hand-rolled
+  `renderBody` at `usePrPanel.ts:955`).
+- **No unconditional interval**: the AI pipeline is opt-in and visibility-gated (mirror the
+  poll discipline at `usePrPanel.ts:990-1020`). Zero work when disabled.
+- **core browser-safe**: `packages/core` stays zero-Node. The only core change is a pure
+  string helper.
+- **Versions**: never hand-edit versions. No `bump-version.sh` in this plan (that's tag-time).
+
+## Test conventions
+
+- Composable/unit tests live in `apps/desktop/src/composables/__tests__/` and
+  `apps/desktop/src/utils/__tests__/`. Composable tests **mock `@/utils/backend`** — this is
+  the established convention (see `useRepoFileTree.test.ts`, `useGitWand-base-recovery.test.ts`);
+  the AGENTS.md "real git repos, no mocked git layer" rule targets Rust tests, not jsdom
+  composable tests that mock the IPC boundary.
+- Pure functions (resolvers, parsers, mergers) are tested with hand-built inputs, no mocks.
+- Parity harness: `apps/desktop/tests/parity/` + `examples/parity_probe.rs`.
+
+---
+
+## Task 0: Surface PR head SHA on `PullRequestDetail` (foundational)
+
+**Why first:** viewed-state invalidation on re-push (B2) and the AI findings/summary cache key
+`repo#number@headSha` (C3, D1) both require a head SHA. Neither `PullRequest` nor
+`PullRequestDetail` currently carries one (verified: `backend-pr.ts:69` and `:452`).
+
+**Files:**
+- Modify: `apps/desktop/src/utils/backend-pr.ts:452` — add `headSha: string;` to
+  `PullRequestDetail`; add `headSha: r.head_sha ?? ""` in the snake→camel mapping of
+  `ghPrDetail` (and the dev-server branch of the same function).
+- Modify Rust detail builders to emit `head_sha`:
+  - `apps/desktop/src-tauri/src/commands/gh.rs` — `gh pr view` `--json` list: add `headRefOid`;
+    map to `head_sha` in the `PullRequestDetail` struct (struct lives in `commands/*` — add the
+    field with `#[serde(rename = "head_sha")]` semantics consistent with siblings).
+  - `apps/desktop/src-tauri/src/commands/gitlab.rs:134` `gl_mr_to_detail` — read
+    `diff_refs.head_sha` (fallback `sha`).
+  - `apps/desktop/src-tauri/src/commands/bitbucket.rs:359` `bb_pr_to_detail` — `source.commit.hash`.
+  - `apps/desktop/src-tauri/src/commands/azure.rs:550` `json_to_detail` —
+    `lastMergeSourceCommit.commitId` (fallback empty).
+  - Add `head_sha: String` to the shared `PullRequestDetail` Rust struct (grep the struct def;
+    it is serialized to the frontend).
+- Modify: `apps/desktop/dev-server.mjs:3137` (gh-pr-detail route) — add `head_sha: pr.head?.sha ?? ""`.
+- Modify parity probe if `gh-pr-detail`/detail is covered (`examples/parity_probe.rs` +
+  `tests/parity/`); if detail is not in the parity set, no probe change (note it in commit body).
+
+**Interfaces:**
+- Produces: `PullRequestDetail.headSha: string` (empty string when a forge can't provide one —
+  callers must treat `""` as "no head SHA known" and skip head-keyed invalidation gracefully).
+
+- [x] **Step 1:** Write `apps/desktop/src/utils/__tests__/backend-pr-headsha.test.ts` — a unit
+  test over the `ghPrDetail` dev-server mapping asserting `head_sha` → `headSha`, and that a
+  missing field maps to `""`. (Mock `devFetch`/`fetch` per existing backend test pattern.)
+- [x] **Step 2:** Add the field to the TS type + mappings and the dev-server route. Run the new
+  test — green.
+- [x] **Step 3:** Add `head_sha` to the Rust struct + all four detail builders. `cargo build`.
+- [x] **Step 4:** `pnpm test:parity` (from `apps/desktop`) — no-op: `PullRequestDetail`/PR-detail
+  routes are not in the parity set (`tests/parity/` only covers git-status/log/branches/stash/
+  submodule); nothing to run.
+
+**Done when:** `p.prDetail.value.headSha` is populated on GitHub + GitLab against a real repo,
+`""` fallback on Bitbucket/Azure when unavailable, all tests green.
+
+**Commit:** `feat(pr-review): surface PR head SHA on PullRequestDetail across forges`
+
+---
+
+## PHASE A — Performance rebuild
+
+### Task A1: Lazy per-file diff parse
+
+**Spec A1.** Keep `getPRDiff` as a single fetch, but stop parsing the whole PR string up front.
+Split the raw unified diff by `diff --git` headers into lightweight per-file slices (index
+only), and parse a file's hunks **only when it is selected**, caching the parsed result.
+
+**Files:**
+- Modify: `apps/desktop/src/composables/usePrPanel.ts`
+  - `parseUnifiedDiff` (`:319-365`) stays but is refactored: extract the per-file hunk parse
+    into `parseFileDiff(rawFileSlice: string): GitDiff` (the current per-file body).
+  - Add `indexDiffFiles(rawDiff: string): { path: string; raw: string }[]` — splits on
+    `diff --git a/… b/…` boundaries, extracts the `b/` path, keeps the raw slice. (Reuse the
+    existing header regex `usePrPanel.ts:329`.)
+  - `loadDiff` (`:631-643`): replace `prDiffFiles.value = parseUnifiedDiff(raw)` with: store
+    the index (a new `diffIndex` ref: `{ path; raw }[]`), set `prDiffFiles.value` to
+    **shells** (`{ path, hunks: [] }`) so the file sidebar renders instantly, select the first
+    file, and parse it lazily.
+  - Add `ensureFileParsed(path: string)`: if the shell for `path` has empty hunks and an index
+    slice exists, run `parseFileDiff` and replace that entry in `prDiffFiles.value` (cache by
+    path — never re-parse). Call it from the `selectedDiffFile` watch and from `selectPr`/first
+    file selection.
+  - Add a `watch(selectedDiffFile, (p) => p && ensureFileParsed(p))`.
+- Keep `selectedDiff` computed (`:295`) working against the now-populated shell.
+
+**Interfaces:**
+- Preserve the diff-parsing gotcha (`AGENTS.md`): context detection via `line.startsWith(' ')`
+  — do not regress the existing `:358` logic when extracting `parseFileDiff`.
+
+- [x] **Step 1:** Write `apps/desktop/src/composables/__tests__/usePrPanel-lazy-diff.test.ts`:
+  - `indexDiffFiles` over a 3-file raw diff → 3 slices with correct `b/` paths and raw bodies.
+  - `parseFileDiff` on one slice equals what `parseUnifiedDiff` produced for that file before
+    (regression parity — build the expectation from a fixture).
+  - Empty-string context lines are classified as context, not added/deleted (gotcha guard).
+- [x] **Step 2:** Implement `indexDiffFiles` + `parseFileDiff`; make tests green. (Moved to
+  module scope + exported, so they're directly unit-testable; `parseUnifiedDiff` now composes
+  them and is kept as a regression-parity helper.)
+- [x] **Step 3:** Wire `loadDiff` + `ensureFileParsed` + the `selectedDiffFile` watch. Added a
+  test asserting that after `loadDiff`, only the first file has non-empty `hunks` and the rest
+  are shells; selecting a second file populates its hunks exactly once (verified the cache guard
+  is load-bearing by temporarily removing it and observing the test fail).
+- [x] **Step 4:** Verify `hotspots`/`fileHistory` loaders (`:900-914`) still get all file paths
+  (they read `prDiffFiles.value.map(f => f.path)` — shells carry `path`, so fine — no code
+  change needed).
+
+**Done when:** opening a 50-file PR parses only the selected file; the file sidebar
+(`PrDetailView.vue:781`) lists all files; switching files parses on demand, once each.
+
+**Commit:** `perf(pr-review): parse PR diff lazily per selected file`
+
+### Task A2: Diff line virtualization
+
+**Spec A2.** Move `PrInlineDiff.vue` line rendering onto `@tanstack/vue-virtual` (already a dep)
+via a shared `useVirtualRows` composable lifted from the variable-height pattern in
+`CommitLog.vue:82-94` (`useVirtualizer` + `measureElement`). Bound the DOM regardless of file
+size; full render fallback under a threshold (< 300 lines) to keep native find/select.
+
+**Files:**
+- Create: `apps/desktop/src/composables/useVirtualRows.ts` — a thin wrapper around
+  `useVirtualizer` generalizing the `CommitLog.vue` setup: takes `count` (Ref), a
+  `scrollElement` getter, `estimateSize`, `overscan`; returns `{ virtualizer, virtualItems,
+  totalSize, measure }`. Include the TDZ-safe post-declaration `setOptions` sync note from
+  `CommitLog.vue:96-101,466-472`.
+- Modify: `apps/desktop/src/components/PrInlineDiff.vue`
+  - The current template nests `v-for hunks` (`:336`) then `v-for lines` (`:390`). Flatten to a
+    single row model: a computed `rows: DiffRow[]` where `DiffRow` is a discriminated union
+    `{ kind: "hunk-header"; hunkIdx } | { kind: "line"; hunkIdx; lineIdx; dl } | { kind:
+    "critique"; hunkIdx } | { kind: "thread"; … } | { kind: "compose"; … }`. (Threads,
+    critique panel, and compose box are currently injected between rows — they must become row
+    kinds so virtualization measures them.)
+  - Under the threshold (`rows.length < 300`): render the existing full DOM (keep current markup
+    path) so Cmd+F and text selection work. At/above threshold: render via `useVirtualRows`
+    with an absolutely-positioned inner container (pattern `CommitLog.vue:676-699`,
+    `:data-index` + `measureElement` ref callback).
+  - Expose an imperative `scrollToHunk(hunkIdx)` and `scrollToLine(rowIdx)` (used by B1
+    keyboard nav) — resolve the row index for a hunk header / line and call
+    `virtualizer.scrollToIndex`. In non-virtual mode, fall back to `el.scrollIntoView`
+    (pattern `DiffViewer.vue:186-190`).
+
+**Interfaces:**
+- Produces: `PrInlineDiff` exposes (`defineExpose`) `{ scrollToHunk, scrollToLine, rows,
+  currentRowIdx }` for the keymap host.
+- Keep all existing emits/props unchanged.
+
+- [x] **Step 1:** Write `apps/desktop/src/composables/__tests__/useVirtualRows.test.ts` —
+  verify it constructs a virtualizer with the given count/estimate and recomputes on count
+  change (mock `@tanstack/vue-virtual`'s `useVirtualizer` and assert options; jsdom has no
+  layout so this is a wiring test, not a pixel test).
+- [x] **Step 2:** Implement `useVirtualRows`; green.
+- [x] **Step 3:** Refactor `PrInlineDiff` to the flat `rows` model. There was no pre-existing
+  `PrInlineDiff` test (component tests weren't in the codebase for this file), so a new
+  `apps/desktop/src/components/__tests__/PrInlineDiff.test.ts` was added (mounted via native
+  `createApp`, matching `LaunchpadView.test`/`MergeEditor.test`) asserting the full-DOM path
+  renders every row (hunk-header/line/CI-annotation) and boxes the hunk visually via
+  `.pid-rowbox--start/--end` (the per-hunk `.pid-hunk` wrapper div couldn't survive flattening
+  to a virtualizable list, so the boxed look is now per-row border/radius classes instead of a
+  group wrapper — documented in a code comment).
+- [x] **Step 4:** Added the virtual path above the 300-row threshold + `defineExpose({
+  scrollToHunk, scrollToLine, rows, currentRowIdx })`. Test asserts a single 5 000-line hunk
+  switches to `.pid-rows--virtual` and keeps the live DOM row count under 200 (jsdom has no
+  real layout, so the exact visible-window count isn't asserted, only that it stays far below
+  the full row count per the plan's own "wiring test, not a pixel test" framing).
+- [x] **Step 5:** `pnpm test` green (428 tests, including the 4 new `PrInlineDiff` tests); no
+  regression in any existing suite; `vue-tsc --noEmit` clean.
+
+**Done when:** a 5 000-line file's diff DOM is bounded (visible + overscan), scroll is smooth,
+< 300-line files still full-render with working native find.
+
+**Commit:** `perf(pr-review): virtualize PR diff line rendering`
+
+### Task A3: Slim detail revalidation (6 → 3 calls)
+
+**Spec A3.** Hot path = `getPR + listComments + listReviews` (3). Defer `getCIChecks` to the
+Checks/Diff tab, `gitFileCount` to the Intelligence lazy loaders, `listIssueComments` to the
+Info tab.
+
+**Files:**
+- Modify: `apps/desktop/src/composables/usePrPanel.ts`
+  - `fetchDetailBundle` (`:564-600`): drop `getCIChecks`, `gitFileCount`, `listIssueComments`
+    from the `Promise.all` — keep `getPR`, `listComments`, `listReviews`. Update the
+    `cache.setDetail` call (bundle no longer includes fresh checks/issueComments/fileCount at
+    this point; keep whatever is cached, see below).
+  - Add lazy loaders mirroring `loadAnnotations` (`:652`): `loadChecks()` (guarded by a
+    `checksLoaded` flag), `loadIssueComments()` (`issueCommentsLoaded`), and move
+    `gitFileCount` into `loadHotspots`/`loadFileHistory` (or a `loadRepoFileCount()` called
+    from the intelligence tab watch).
+  - Update the `watch(detailTab)` (`:687-698`): `diff`/`checks` → `loadChecks()` (+ existing
+    `loadAnnotations`); `info` → `loadIssueComments()`; `intelligence` → ensure file count is
+    loaded.
+  - `usePrCache.DetailBundle` (`usePrCache.ts:37-43`) currently requires `checks` +
+    `issueComments`. Make them optional (`checks?`, `issueComments?`) OR keep them and have the
+    lazy loaders write-through via `persistDetailCache` (`:612`). Prefer optional fields +
+    default `[]` on read to avoid a cache-shape migration; bump nothing — old entries with the
+    fields still parse.
+  - The 5-min poll (`revalidateOpenDetail` → `fetchDetailBundle`, `:603-607`) now also only
+    hits 3 calls. Good — that was half the spec's win.
+
+- [x] **Step 1:** Extend `usePrPanel-*.test.ts` (new file
+  `usePrPanel-revalidation.test.ts`): mock the forge, call `selectPr`, assert exactly
+  `getPR` + `listComments` + `listReviews` fire and `getCIChecks`/`gitFileCount`/
+  `listIssueComments` do **not** on the hot path.
+- [x] **Step 2:** Assert switching to the `checks` tab triggers `getCIChecks` once (and not
+  again on re-switch); `info` triggers `listIssueComments` once; `intelligence` triggers the
+  file count.
+- [x] **Step 3:** Implement; made `DetailBundle.checks`/`.issueComments` optional; green.
+  (Diff tab also calls `loadChecks()` per the plan's own file note — CI gutter icons on the
+  Diff tab need checks too, not just the Checks tab.)
+- [x] **Step 4:** Confirmed `totalRepoFiles`-dependent UI (Intelligence panel scope) still
+  works once its tab is opened — `loadRepoFileCount()` populates `totalRepoFiles` lazily,
+  same ref, no consumer change needed.
+
+**Done when:** opening a PR detail issues 3 forge calls; deferred data loads on its tab, once.
+
+**Commit:** `perf(pr-review): slim detail revalidation to 3 hot-path calls`
+
+---
+
+## PHASE B — Review flow (keyboard-first + viewed)
+
+### Task B1: GitHub-standard keymap (pure resolver + Diff-tab wiring)
+
+**Spec B1.** `J`/`K` next/prev hunk (crosses file boundaries), `⇧J`/`⇧K` next/prev file,
+`V` toggle viewed, `⇧V` hide/show viewed, `T` file filter, `C` comment current hunk, `?` help,
+`N`/`P` next/prev finding (finding nav lands with C4; reserve them here), `⌘Enter` submit
+review (B3). Strict focus guard: inert in any input/textarea/contenteditable/palette.
+
+**Files:**
+- Create: `apps/desktop/src/composables/usePrReviewKeymap.ts`
+  - Pure resolver `export function resolvePrReviewShortcut(e: KeyboardEvent, ctx: { focused:
+    boolean }): PrReviewAction | null` returning a discriminated union: `"next-hunk" |
+    "prev-hunk" | "next-file" | "prev-file" | "toggle-viewed" | "toggle-hide-viewed" |
+    "filter-files" | "comment-hunk" | "help" | "next-finding" | "prev-finding" |
+    "submit-review"`. Mirror `resolveTerminalShortcut` (`useTerminalSessions.ts:12-20`): return
+    `null` when `!focused`, when a modifier that doesn't belong is held, or when the key is
+    unmapped. `⌘Enter` → `submit-review`; plain letters → their actions; `Shift` distinguishes
+    `J/⇧J`, `K/⇧K`, `V/⇧V`.
+  - Export `isEditableTarget(el: EventTarget | null): boolean` (input/textarea/select/
+    contenteditable) so the host can compute `focused = !isEditableTarget(document.activeElement)
+    && diffTabActive`.
+- Modify: `apps/desktop/src/components/PrDetailView.vue`
+  - Add a `keydown` listener (mounted/unmounted) that: returns early unless
+    `p.detailTab.value === 'diff'` and the detail view is open; computes `focused` via
+    `isEditableTarget`; calls `resolvePrReviewShortcut`; dispatches. `preventDefault` only on a
+    matched action. Must not swallow `Escape`/`⌘⇧L` (leave those to `App.vue`) — the resolver
+    doesn't map them, so returning `null` lets them bubble.
+  - Dispatch handlers call into the `PrInlineDiff` exposed API (`scrollToHunk`,
+    `scrollToLine`) and `usePrPanel` state (file switching via `selectedDiffFile`, viewed
+    toggle from B2, comment-hunk opens the compose box on the current hunk, help sets
+    `showHelp`, submit-review from B3).
+  - Track "current hunk/file" cursor state (a `currentHunkIdx` ref, seeded to 0; `J`/`K` step
+    within the flattened row model, crossing into the next/prev file when past the last/first
+    hunk — advance `selectedDiffFile` accordingly).
+- Modify: `apps/desktop/src/components/HelpView.vue:43-55` — add the PR-review shortcuts to the
+  `shortcuts` array with new `help.keyboardShortcuts.*` locale keys (`J`, `K`, `⇧J`, `⇧K`, `V`,
+  `⇧V`, `T`, `C`, `N`, `P`, `⌘↵`). Group under a "PR Review" heading if the section supports it.
+
+- [x] **Step 1:** Write `apps/desktop/src/composables/__tests__/usePrReviewKeymap.test.ts` —
+  exhaustive resolver cases: each key → action; `Shift` variants; `⌘Enter`; `focused: false`
+  → always `null`; unmapped keys → `null`; modifier noise (`Ctrl+J`) → `null` unless mapped.
+  Plus `isEditableTarget` over input/textarea/contenteditable/div.
+- [x] **Step 2:** Implement the resolver + `isEditableTarget`; green.
+- [x] **Step 3:** Wired the listener in `PrDetailView.vue` (extended its existing single
+  `handleKeydown`, matching the codebase's one-listener-per-component pattern, rather than
+  adding a second `window` listener). Took the plan's own "focused composable test on an
+  extracted dispatch function" alternative: extracted the hunk/file cursor + dispatch logic
+  into `usePrReviewNav.ts` (business logic belongs in composables — AGENTS.md) instead of a
+  full mount test of the very large `PrDetailView.vue`, and unit-tested that directly
+  (`usePrReviewNav.test.ts`, 6 cases: next/prev hunk, file-boundary crossing, `⇧J` wrap +
+  cursor reset, comment-hunk, help, and the B2/B3/C4 actions being safe no-ops for now).
+  `Escape` still closes the fullscreen-image overlay unchanged (same `handleKeydown`, existing
+  branch untouched).
+- [x] **Step 4:** Added HelpView entries (`pr*` shortcut rows) + 5-locale keys. Locale files are
+  actually named `pt-BR.ts`/`zh-CN.ts` in this repo (not the plan's `pt-br.ts`/`zh-cn.ts`) — used
+  the real filenames.
+
+**Done when:** a full review is drivable from the keyboard on the Diff tab; typing in a comment
+box never triggers navigation; Escape/⌘⇧L still work.
+
+**Commit:** `feat(pr-review): keyboard-first review keymap on the Diff tab`
+
+### Task B2: Viewed-file state
+
+**Spec B2.** Client-side per-PR viewed state in the SWR cache, keyed `repo#number`, invalidated
+per file when the head SHA changes (re-push → changed files revert to unviewed). Checkbox per
+file in the diff sidebar + "X/N viewed" progress + hide-viewed toggle. Extend
+`SubmitReviewOptions` with optional `viewedFiles?: string[]` (optional forge transport; client
+is source of truth).
+
+**Files:**
+- Modify: `apps/desktop/src/composables/usePrCache.ts`
+  - Add a `viewed` record to `PrCacheFile`: `viewed: Record<string, { headSha: string; paths:
+    string[]; ts: number }>` keyed by `detailKey(cwd, number)`.
+  - Add `getViewed(key): { headSha; paths } | null`, `setViewed(key, headSha, paths)`,
+    `toggleViewed(key, headSha, path)` (adds/removes a path; **resets `paths` to `[path]`-less
+    when `headSha` differs** from the stored one, then applies the toggle — this is the
+    "re-push invalidates viewed" behavior at the whole-PR granularity; if per-file blob-SHA
+    granularity is wanted later it's a follow-up, note it). Prune with the existing
+    `pruneByAge`/`evictLru` machinery (add to `loadFromStorage`/`saveToStorage`).
+- Modify: `apps/desktop/src/composables/forge/types.ts:77-81` — add
+  `viewedFiles?: string[];` to `SubmitReviewOptions` (documented as client-tracked, optional
+  forge transport; GitHub has no native API so providers may ignore it).
+- Modify: `apps/desktop/src/composables/usePrPanel.ts`
+  - Add `viewedPaths = ref<Set<string>>()`, load from cache in `selectPr` using
+    `prDetail.headSha` (from Task 0). Add `toggleViewed(path)`, `viewedCount` computed,
+    `hideViewed = ref(false)`, and a `visibleDiffFiles` computed that filters `prDiffFiles` when
+    `hideViewed`. Reset on PR switch.
+  - Include `viewedFiles: [...viewedPaths.value]` in `handleSubmitReview`'s `opts` (`:860`).
+- Modify: `apps/desktop/src/components/PrDetailView.vue:778-801` (diff sidebar) — per-file
+  checkbox bound to `viewedPaths`, a "X/N viewed" progress line, and a "hide viewed" toggle;
+  the file list iterates `visibleDiffFiles`. Wire `V`/`⇧V` (B1) to `toggleViewed(current)` /
+  `hideViewed` toggle.
+
+- [x] **Step 1:** Write `usePrCache-viewed.test.ts`: `setViewed`/`getViewed` round-trip;
+  `toggleViewed` adds then removes; a `toggleViewed` with a **new** `headSha` clears prior
+  paths first (re-push invalidation); age/LRU pruning includes the `viewed` record.
+- [x] **Step 2:** Implement cache methods; green.
+- [x] **Step 3:** Write `usePrPanel-viewed.test.ts`: selecting a PR seeds `viewedPaths` from
+  cache; `toggleViewed` updates count + persists; `handleSubmitReview` forwards `viewedFiles`;
+  changing `prDetail.headSha` resets viewed on next toggle. (Exported `revalidateOpenDetail`
+  from `usePrPanel` — it existed internally for the 5-min poll but wasn't reachable from tests
+  or any manual-refresh UI; needed here to simulate a re-push landing.) Also wired
+  `toggle-viewed`/`toggle-hide-viewed` into `usePrReviewNav`'s dispatch (was a no-op stub left
+  by B1) with 2 new test cases there.
+- [x] **Step 4:** Wired the sidebar UI (checkbox per file, progress line, hide-viewed toggle
+  button) + 5-locale keys (`pr.viewed.progress`, `.hide`, `.toggle`).
+
+**Done when:** viewed state persists across close/reopen, survives repo switch, resets for
+changed files on re-push (headSha change), and the progress bar + hide toggle work.
+
+**Commit:** `feat(pr-review): client-side viewed-file state with re-push invalidation`
+
+### Task B3: Pending review surfaced (badge + resume + ⌘Enter)
+
+**Spec B3.** Persistent counter badge (drafts already survive tab switch; the badge is missing),
+resume the draft after close/reopen (persist to SWR cache), and `⌘Enter` submits the review.
+
+**Files:**
+- Modify: `apps/desktop/src/composables/usePrCache.ts` — add `drafts: Record<string,
+  { comments: PendingReviewComment[]; ts: number }>` keyed `detailKey`; `getDraft`,
+  `setDraft`, `clearDraft`. Prune/evict like the others. (Import `PendingReviewComment` from
+  `backend.ts`.)
+- Modify: `apps/desktop/src/composables/usePrPanel.ts`
+  - Persist `draftReviewComments` to the cache on every `handleAddToReview` (`:847`) and clear
+    on successful `handleSubmitReview` (`:870`); seed from cache in `selectPr`.
+  - Add a `draftCount` computed (already available via `.length`, but expose a named badge
+    value). No new interval.
+- Modify: `apps/desktop/src/components/PrDetailView.vue` — a persistent badge on the Diff tab
+  (or a floating "N in review" chip near the review action) bound to `draftReviewComments.length`,
+  visible across tabs while > 0. Wire `⌘Enter` (from B1 `submit-review`) to open the review
+  modal / submit (respect `submittingReview`).
+
+- [x] **Step 1:** `usePrCache-draft.test.ts`: draft round-trip + clear + prune.
+- [x] **Step 2:** `usePrPanel-draft.test.ts`: `handleAddToReview` persists; `selectPr` restores
+  the draft for the same PR; `handleSubmitReview` clears it; switching PRs isolates drafts by
+  key.
+- [x] **Step 3:** Implement cache + composable wiring; green.
+- [x] **Step 4:** `⌘Enter` dispatch wired (opens the review modal via `usePrReviewNav`'s
+  `submit-review` case, respecting `submittingReview`). The persistent badge UI **already
+  existed** on the always-rendered tab bar (`PrDetailView.vue`'s `.pdv-review-btn`/
+  `.pdv-review-count`, bound to `draftReviewComments.length`) — the plan's audit note that "the
+  badge is missing" didn't match the current code; the real gap was persistence across detail
+  close/reopen, which Steps 1-3 fix. No new locale keys needed (no new UI strings — the badge
+  reuses existing markup/keys).
+
+**Done when:** staged comments survive detail close/reopen, the badge reflects the count from
+any tab, `⌘Enter` submits.
+
+**Commit:** `feat(pr-review): persist and surface the pending review draft`
+
+### Task B4: Dismiss review + request reviewers
+
+**Spec B4.** New forge methods `dismissReview` and `requestReviewers` (GitHub real; GitLab real
+if the API allows, else honest `ForgeNotImplementedError` — never silent degradation). UI in
+the Info tab: reviews list + reviewer picker reusing `listReviewerCandidates` (already real on
+all 4 forges).
+
+**Files:**
+- Modify: `apps/desktop/src/composables/forge/types.ts` — add to `ForgeProvider`:
+  `dismissReview(cwd, prNumber, reviewId, message?): Promise<void>` and
+  `requestReviewers(cwd, prNumber, logins: string[]): Promise<void>` (both optional `?` on the
+  interface so incomplete providers can omit; callers treat absence as unsupported and hide the
+  action).
+- Implement on providers:
+  - `GitHubProvider` — real. Add backend wrappers in `backend-pr.ts` (`ghDismissReview`,
+    `ghRequestReviewers`) + Rust commands `gh_dismiss_review` (`gh api … /reviews/:id/dismissals`)
+    and `gh_request_reviewers` (`gh api … /requested_reviewers`), registered in `lib.rs`, with
+    `dev-server.mjs` routes (parity). Follow the checklist in `src-tauri/CLAUDE.md` §"Ajouter
+    une nouvelle commande Tauri".
+  - `GitLabProvider` (`GitLabProvider.ts`) — `requestReviewers` real via
+    `PUT /merge_requests/:iid?reviewer_ids=…` (add `gl_request_reviewers`); `dismissReview` →
+    GitLab has no direct equivalent → `throw new ForgeNotImplementedError("gitlab",
+    "dismissReview")`.
+  - `BitbucketProvider`/`AzureProvider` — omit the methods (or throw
+    `ForgeNotImplementedError`); UI hides the actions.
+- Modify: `apps/desktop/src/composables/usePrPanel.ts` — `handleDismissReview(reviewId)` and
+  `handleRequestReviewers(logins)` calling the forge, refreshing `prReviews`/`prDetail`,
+  surfacing `ForgeNotImplementedError` as a disabled/hidden action (not an error banner).
+- Modify: `apps/desktop/src/components/PrDetailView.vue` (Info tab, `:549`) — a reviews list
+  with a per-review "Dismiss" button (guarded by capability), and a reviewer picker
+  (reuse/mirror the create-form reviewer picker; source from `listReviewerCandidates`).
+
+- [x] **Step 1:** Parity/unit: `backend-pr` wrappers tested against the dev-server mock shape
+  (`gh-dismiss-review`, `gh-request-reviewers` routes return `{ ok: true }` on success).
+- [x] **Step 2:** `usePrPanel-review-admin.test.ts`: `handleRequestReviewers` calls the forge
+  and refreshes; `handleDismissReview` on a provider that throws `ForgeNotImplementedError`
+  does **not** set `error` (action treated as unsupported). Found and fixed a real bug while
+  writing this test: the check was `err.message?.includes("ForgeNotImplementedError")`, but
+  the class only sets that string on `.name`, never in `.message` — so the guard never actually
+  matched and would have leaked the error to the banner for real GitLab dismiss attempts. Fixed
+  in the two new handlers via `err instanceof ForgeNotImplementedError` (imported from
+  `forge/types`). Left the pre-existing `convertDraftToReady` occurrence of the same bug
+  untouched (`usePrPanel.ts` — that call path is currently unreachable dead code since no
+  provider throws `ForgeNotImplementedError` for `convertDraftToReady`, but fixing unrelated
+  pre-existing code is out of this task's scope).
+- [x] **Step 3:** Implemented Rust commands (`gh_dismiss_review`, `gh_request_reviewers`) +
+  wrappers + dev-server routes; `cargo build` green. `pnpm test:parity` — same no-op as Task 0
+  (these commands aren't in the parity set) plus the harness itself couldn't bind a local port
+  in this sandboxed environment (`EPERM`, pre-existing/unrelated to this change).
+- [x] **Step 4:** GitLab `requestReviewers` real (new `gl_request_reviewers` Rust command,
+  resolves usernames → numeric member ids, then `PUT` with `reviewer_ids[]`) + `dismissReview`
+  honest `ForgeNotImplementedError` throw. `GitLabProvider.test.ts` created (new file, F1 will
+  extend it).
+- [x] **Step 5:** Info-tab UI: a "Dismiss" button per non-dismissed review in the timeline, and
+  a reviewer-request input (native `<datalist>` sourced from `listReviewerCandidates`, not the
+  full custom autocomplete from `PrCreateView.vue` — a lighter-weight but data-source-equivalent
+  picker, given the full component is tightly coupled to create-PR-specific state). Both gated
+  by `forgeSupportsDismissReview`/`forgeSupportsRequestReviewers` computeds (hidden, not
+  erroring, on GitLab/Bitbucket/Azure where unsupported). 5-locale keys added under a new
+  `pr.reviews.*` namespace (distinct from the existing singular `pr.review.*` modal namespace).
+
+**Done when:** on GitHub you can dismiss a review and request reviewers from the Info tab;
+GitLab can request reviewers and cleanly reports dismiss as unsupported; Bitbucket/Azure hide
+the actions.
+
+**Commit:** `feat(pr-review): dismiss review and request reviewers (GitHub real, honest stubs)`
+
+---
+
+## PHASE E1 — Shared line-annotation model (prerequisite for C4)
+
+### Task E1: `LineAnnotation` type + merged annotation stream in `PrInlineDiff`
+
+**Spec E1.** A shared `LineAnnotation` with `source: "ci" | "ai" | "static"`, open severity
+(preserve AI confidence/severity rather than the 3-level `mapAnnotation` normalization), and
+old/new-side matching (LEFT/RIGHT already modeled by comments). `PrInlineDiff` consumes a merged
+CI + AI + static-flags stream with distinct icons/labels per source.
+
+**Files:**
+- Create: `apps/desktop/src/composables/prAnnotations.ts` (pure module) — define:
+  ```ts
+  export interface LineAnnotation {
+    source: "ci" | "ai" | "static";
+    path: string;
+    line: number;                 // anchor line
+    side: "LEFT" | "RIGHT";       // default RIGHT (new side)
+    endLine?: number;
+    severity: string;             // open scale: "failure"|"warning"|"notice"|"risk"|"suggestion"|"nit"|…
+    confidence?: number;          // 0-100, AI only
+    title: string;
+    message?: string;
+    checkName?: string;           // ci source
+    id?: string;                  // stable id for dismissal/nav (ai)
+  }
+  export function fromCIAnnotation(a: CIAnnotation): LineAnnotation;   // maps existing v2.18 shape, source "ci"
+  export function annotationsByLine(anns: LineAnnotation[], cap?: number): Map<string, LineAnnotation[]>;
+  //   key = `${side}:${line}` so LEFT/RIGHT don't collide; reuse the ANN_RANGE_CAP=20 expansion
+  export function worstSeverity(anns: LineAnnotation[]): string;
+  ```
+- Modify: `apps/desktop/src/components/PrInlineDiff.vue`
+  - Replace the CI-only `annotationsByLine`/`annotationsForLine` (`:172-195`, new-side only)
+    with the shared helpers, matching both sides. Add a new prop
+    `annotations?: LineAnnotation[]` (replacing the current `annotations?: CIAnnotation[]` prop
+    at `:35`) — the host converts CI annotations via `fromCIAnnotation` and merges AI/static.
+    Per-source icon + label (CI: existing `❌/⚠/ℹ`; AI: `AiSparkle` + confidence chip; static:
+    a distinct badge).
+  - Keep the gutter tooltip; show `confidence` for AI rows.
+- Modify: `apps/desktop/src/composables/usePrPanel.ts` — add an `annotationsForFileMerged`
+  computed (or defer the merge to E2's `useReviewIntelligence`; for E1 just convert CI via
+  `fromCIAnnotation` so the prop type flips without behavior change). AI/static feed lands in
+  C4/E2.
+- Modify: `apps/desktop/src/components/PrDetailView.vue:814` — pass the converted
+  `LineAnnotation[]` to `PrInlineDiff`.
+
+- [x] **Step 1:** `apps/desktop/src/composables/__tests__/prAnnotations.test.ts`:
+  `fromCIAnnotation` mapping; `annotationsByLine` keys by side+line and caps ranges at 20;
+  LEFT and RIGHT annotations on the same number don't merge; `worstSeverity` ordering.
+- [x] **Step 2:** Implement the module; green.
+- [x] **Step 3:** Flipped `PrInlineDiff`'s prop to `LineAnnotation[]`, wired the shared helpers.
+  CI matching stays RIGHT-only (byte-identical) since `fromCIAnnotation` always sets `side:
+  "RIGHT"`; LEFT-side matching on delete lines is purely additive (delete lines never matched
+  anything before, since they have no `newLineNo`) — verified via the existing `PrInlineDiff`
+  CI-annotation regression test (A2's test file), updated to the new prop shape, still green.
+  Also added a confidence chip + source fallback in the tooltip (ready for C4's AI findings)
+  without changing CI-only visual output (confidence is `undefined` for CI annotations, so the
+  chip doesn't render).
+- [x] **Step 4:** Converted at the `usePrPanel` boundary: `lineAnnotationsByFile` (new,
+  `LineAnnotation[]`) sits alongside the existing `annotationsByFile` (unchanged, still
+  `CIAnnotation[]`, still used for the file-sidebar badge count) rather than replacing it —
+  `PrDetailView.vue` now passes `lineAnnotationsByFile` to `PrInlineDiff`. `pnpm test` green
+  (491 tests).
+
+**Done when:** CI annotations render exactly as before but through the unified `LineAnnotation`
+path, matched on both sides, ready to accept AI + static sources.
+
+**Commit:** `refactor(pr-review): unify diff annotations under a LineAnnotation model`
+
+---
+
+## PHASE E3 — Review AI settings surface (before C, so C can read the opt-ins)
+
+### Task E3: One "Review AI" settings section
+
+**Spec E3.** A single "Review AI" section in Settings: provider inherited from `useAIProvider`,
+opt-in pre-review, confidence threshold, cap, opt-in summary. Added to `AppSettings`
+(`useSettings.ts`) **and** `SettingsPanel.vue` (sync rule).
+
+**Files:**
+- Modify: `apps/desktop/src/composables/useSettings.ts` — add to `AppSettings` (near the AI
+  block `:141-160`) and to `DEFAULT_SETTINGS` (`:378`):
+  ```ts
+  reviewAiPreReview: boolean;     // default false (opt-in)
+  reviewAiConfidenceThreshold: number; // default 60
+  reviewAiMaxFindings: number;    // default 15
+  reviewAiSummary: boolean;       // default false (opt-in)
+  ```
+- Modify: `apps/desktop/src/components/SettingsPanel.vue` — mirror the four fields in the local
+  `Settings` interface (`:147`) + defaults (`:232`), and render controls in the AI section
+  (`:558+`): a "Review AI" subsection with toggles (pre-review, summary), a threshold slider
+  (0–100), and a cap number input. Reuse `updateSetting`. Gate the subsection behind
+  `aiEnabled` (like other AI controls).
+- 5-locale keys: `settings.reviewAi.title`, `.preReview`, `.threshold`, `.cap`, `.summary`,
+  and helper descriptions.
+
+- [x] **Step 1:** `useSettings-reviewAi.test.ts` (new file — no pre-existing `useSettings` test
+  to extend): the four fields exist in `defaultAppSettings` (the plan's `DEFAULT_SETTINGS` name
+  doesn't match this codebase's actual export) with the specified defaults, round-trip through
+  `saveSettings`/`loadSettings`, and a legacy stored payload missing the new keys backfills
+  the defaults on load.
+- [x] **Step 2:** Implemented in `useSettings.ts` (`AppSettings` + `defaultAppSettings`) and
+  `SettingsPanel.vue` (local `Settings` + its defaults object) in the same commit — sync rule.
+  UI: a "Review AI" group in the AI settings tab (pre-review toggle, confidence slider + cap
+  number input gated behind it, summary toggle), reusing the existing `sp-group`/`sp-range`/
+  `sp-checkbox` patterns from the adjacent LLM-fallback section.
+- [x] **Step 3:** Added 5-locale keys under `settings.reviewAi.*`; `vue-tsc --noEmit` clean
+  (would catch a missing `LocaleKey` at the `t()` call sites since keys are typed).
+
+**Done when:** the Review AI section renders, toggles persist, defaults match the spec, and the
+`AppSettings`/`SettingsPanel` interfaces are in sync.
+
+**Commit:** `feat(pr-review): Review AI settings section (opt-in, threshold, cap, summary)`
+
+---
+
+## PHASE C — AI pre-review pass (local-first, Greptile-style)
+
+### Task C0: Export import-source extraction from core
+
+**Spec C1 hop 2.** The dependency hop extracts import specifiers from touched files
+(extraction only, no graph — the resolved graph is v4.0). `parseImport` in
+`packages/core/src/resolvers/imports.ts:84` is private; expose a pure extraction helper.
+
+**Files:**
+- Modify: `packages/core/src/resolvers/imports.ts` — add and export:
+  ```ts
+  export function extractImportSources(content: string): string[];
+  // scans lines with the existing isImportLike / RE_IMPORT_FROM / RE_REQUIRE / RE_EXPORT_FROM
+  // regexes; returns the deduped list of module specifiers (the `source` field). Pure string
+  // work — zero Node. Reuses parseImport internally.
+  ```
+- Modify: `packages/core/src/index.ts:68` — add `extractImportSources` to the public export
+  alongside `tryResolveImportConflict, isImportBlock`.
+
+- [x] **Step 1:** `packages/core/src/__tests__/resolvers/import-extract.test.ts` — extracts
+  `react`, `../utils`, side-effect imports, `require(...)`, `export … from`; dedupes; ignores
+  non-import lines; returns `[]` on empty. (9 cases; core rule ≥ 5.) Found and worked around a
+  pre-existing limitation of the reused `RE_EXPORT_FROM` regex: braced named re-exports
+  (`export { foo } from …`) aren't matched (the character class is missing `}`), only `export *
+  from …` is — this is existing conflict-resolution regex behavior, not something introduced or
+  fixed here, so the re-export test case uses the form the regex actually supports and notes why.
+- [x] **Step 2:** Implemented; `cd packages/core && pnpm test` green (974 tests). No Node
+  import in `resolvers/imports.ts` (browser-safe rule) — confirmed via `grep '^import'` (zero
+  matches) and a clean `pnpm build`.
+
+**Done when:** `@gitwand/core` exports `extractImportSources`, tested, still browser-safe.
+
+**Commit:** `feat(core): export extractImportSources for the PR dependency hop`
+
+### Task C1: Pre-review pipeline (hops → findings)
+
+**Spec C1.** Multi-hop, background, opt-in: (1) diff hunks (reuse A1 parse), (2) dependency
+extraction + cross-referencing touched paths, (3) blame/history of changed lines, (4) structured
+findings via strict JSON.
+
+**Files:**
+- Create: `apps/desktop/src/composables/usePrPreReview.ts` (the engine; E2 later folds it into
+  `useReviewIntelligence`):
+  ```ts
+  export interface ReviewFinding {
+    id: string;                 // hash of path+line+title (stable, for dismissal/nav)
+    path: string; line: number; side: "LEFT" | "RIGHT";
+    severity: "risk" | "suggestion" | "nit";
+    confidence: number;         // 0-100
+    title: string; detail: string;
+  }
+  ```
+  - `buildSystemPrompt(locale)` → asks for strict JSON array of findings
+    `{path,line,side,severity,confidence,title,detail}` (mirror the strict-JSON contract style
+    of `usePrHunkCritique.ts:30-62`).
+  - `buildUserPrompt(file, hunks, importSources, blameContext)` — per file: the hunks (reuse
+    `parseFileDiff` output), the extracted import specifiers (from `extractImportSources` over
+    the file's new content — obtained via `getPRDiff` slices; for touched-by-N-diff-files
+    signal, cross-reference specifiers against the set of paths in the PR), and a compact blame
+    summary of changed lines (`getGitBlame` `backend.ts:1118` + last-commit message via
+    `gitExec` `["log","-1","--format=%s","-L",…]` or the `useBlameContext` pattern
+    `useBlameContext.ts:123-127`).
+  - `parseFindings(raw): ReviewFinding[]` — defensive fence/brace recovery exactly like
+    `usePrHunkCritique.ts:78-99`, but for an **array**; clamp `confidence` to 0–100; coerce
+    unknown severity to `"suggestion"`; drop entries missing `path`/`line`/`title`; assign `id`.
+  - `analyzeFile(file, ctx): Promise<ReviewFinding[]>` — one `ai.rawPrompt` call per file
+    (the concurrency-1 unit for C3).
+
+- [x] **Step 1:** `usePrPreReview.test.ts` (mocks `useAIProvider` + `@/utils/backend`, 18
+  cases): `parseFindings` recovers a JSON array from a ```json fence, from surrounding prose,
+  clamps confidence, coerces bad severity, drops malformed entries, assigns stable ids;
+  dependency hop cross-reference; blame-summary matching; `analyzeFile` returns `[]` gracefully
+  on junk / AI-unavailable.
+- [x] **Step 2:** Implemented the prompt builders + parser + `analyzeFile`; green. Adapted from
+  plan: `computeImportedByCount`/`summarizeBlameForFile` are separate exported pure helpers
+  (not inlined in `analyzeFile`) so the dependency and history hops are independently testable,
+  matching the codebase's "pure functions tested with hand-built inputs" convention.
+- [x] **Step 3:** Blame hop test: `analyzeFile` calls `getGitBlame(cwd, path)` (whole-file, no
+  line-range param exists on that backend function) and includes the matching lines' "author:
+  summary" in the prompt. Documented in code that this reflects the *current checkout*, not a
+  base-relative blame — no Rust command exists for base-relative blame, and adding one would be
+  scope creep beyond C1's "reuse `getGitBlame`" instruction.
+
+**Done when:** given a parsed file + PR context, the engine produces validated `ReviewFinding[]`
+with confidence, anchored to lines, robust to malformed LLM output.
+
+**Commit:** `feat(pr-review): local multi-hop pre-review finding engine`
+
+### Task C2: Signal/noise — threshold, cap, dismissal memory
+
+**Spec C2.** User confidence threshold (default 60), top-N cap by confidence (default 15), and
+local dismissal memory: a dismissed finding persists per repo (class = `path glob + normalized
+title`) and future similar occurrences are suppressed below the threshold.
+
+**Files:**
+- Create: `apps/desktop/src/composables/usePrFindingFilter.ts` (pure):
+  ```ts
+  export function normalizeFindingClass(f: { path: string; title: string }): string;
+  //   e.g. dirname-glob(path) + "::" + title.toLowerCase().replace(/\d+/g,"#").trim()
+  export function filterFindings(all: ReviewFinding[], opts: {
+    threshold: number; cap: number; dismissed: Set<string>;   // set of normalized classes
+  }): ReviewFinding[];
+  //   drop below threshold; drop dismissed classes; sort by confidence desc; take top `cap`.
+  ```
+- Modify: `apps/desktop/src/composables/usePrCache.ts` — add per-repo dismissal memory:
+  `dismissedFindings: Record<string /*cwd*/, { classes: string[]; ts: number }>` +
+  `getDismissed(cwd)`, `addDismissed(cwd, cls)`. Pruned/evicted like the rest.
+
+- [x] **Step 1:** `usePrFindingFilter.test.ts` (8 cases): threshold filtering; cap keeps
+  highest confidence; dismissed class removed; `normalizeFindingClass` collapses digit variance
+  and path-dirname so "same class, different line/number" matches.
+- [x] **Step 2:** `usePrCache-dismissed.test.ts` (7 cases): add/get round-trip, idempotent
+  add, per-repo scoping, cold-start persistence, age-pruning.
+- [x] **Step 3:** Implemented both; green (527 tests total).
+
+**Done when:** findings shown are ≤ cap, all ≥ threshold, and a dismissed class stays hidden on
+recompute and across sessions (same repo).
+
+**Commit:** `feat(pr-review): confidence threshold, cap, and dismissal memory for findings`
+
+### Task C3: Execution — bounded, cancellable, visibility-gated, headSha-cached
+
+**Spec C3.** Work queue with concurrency 1 (each call = a subprocess spawn), cancellable (PR
+switch / close), visibility-gated like the poll. SWR cache by `repo#number@headSha` — never
+recomputed while head is unchanged. Visible status ("Pre-review: 4/12 files…") with findings
+streamed in.
+
+**Files:**
+- Create: `apps/desktop/src/composables/usePrReviewQueue.ts` (or fold into `usePrPreReview`):
+  - `run(files, ctx, { onFinding, signal })`: sequential `for` over files, `await
+    analyzeFile`, emit findings as they land, bail if `signal.aborted` or `document.hidden`
+    (re-check between files). Concurrency is 1 by construction.
+  - Progress state: `{ done, total, running }` refs.
+- Modify: `apps/desktop/src/composables/usePrCache.ts` — findings cache keyed by
+  `${detailKey}@${headSha}`: `findings: Record<string, { findings: ReviewFinding[]; ts: number
+  }>` + `getFindings(key)`, `setFindings(key, findings)`. On a headSha change the old key simply
+  misses → recompute; prune/evict as usual.
+- Modify: `apps/desktop/src/composables/usePrPanel.ts` (thin orchestration for now; E2 unifies):
+  - Trigger the pipeline on PR select **only if** `settings.reviewAiPreReview` and
+    `ai.isAvailable` and `prDetail.headSha` is non-empty. First check the findings cache for
+    `key = detailKey@headSha`; on hit, paint instantly and skip compute.
+  - Use an `AbortController` reset on PR switch / detail close / `cwd` change (extend the
+    existing reset in `resetDetail` `:518` and the `cwd` watcher `:708`).
+  - Gate on visibility: pause when `document.hidden`, resume on `visibilitychange` (reuse the
+    existing handler wiring `:1011-1025` rather than adding a second listener — extend
+    `handleVisibilityChange` to also resume the queue).
+  - Expose `preReviewFindings`, `preReviewProgress`, `preReviewRunning`, `dismissFinding(id)`
+    (adds the finding's class to `usePrCache.addDismissed` and removes it live).
+
+- [x] **Step 1:** `usePrReviewQueue.test.ts` (4 cases): processes files sequentially (assert
+  `analyzeFile` never overlaps via a call-order probe); aborts mid-run when the signal fires;
+  stops when `document.hidden` is simulated and resumes after `resume()`; an abort while paused
+  unblocks the wait (doesn't hang).
+- [x] **Step 2:** `usePrCache-findings.test.ts` (3 cases): findings round-trip by `key@headSha`;
+  a different headSha misses; persists across cold start.
+- [x] **Step 3:** `usePrPanel-prereview.test.ts` (4 cases): disabled setting → zero `rawPrompt`
+  calls; enabled + cache hit → zero compute, instant paint; enabled + miss → runs, populates,
+  and writes through to the cache; PR switch aborts the in-flight run and the stale finding
+  never reaches the new PR's state nor gets cached under the old PR's key.
+- [x] **Step 4:** Implemented. No unconditional interval added — the queue reuses
+  `usePrPanel`'s existing single `visibilitychange` listener (extended to call
+  `reviewQueue.resume()`) rather than adding a second one, per the perf invariant.
+
+**Done when:** pre-review runs opt-in only, one file at a time, cancels on PR switch, never
+recomputes at constant headSha, pauses when hidden, and streams findings with a visible count.
+
+**Commit:** `feat(pr-review): bounded, cancellable, headSha-cached pre-review execution`
+
+### Task C4: Render findings (LineAnnotation + list + N/P nav)
+
+**Spec C4.** Findings anchored in the diff via the generalized annotation overlay (E1), a
+confidence-sorted list in the Intelligence panel, and finding-next/prev keyboard nav (`N`/`P`).
+
+**Files:**
+- Modify: `apps/desktop/src/composables/prAnnotations.ts` — add `fromFinding(f: ReviewFinding):
+  LineAnnotation` (`source: "ai"`, carries `confidence`, `severity`, `id`).
+- Modify: `apps/desktop/src/composables/usePrPanel.ts` — merge `preReviewFindings` (converted
+  via `fromFinding`, filtered by C2) with CI annotations into the `LineAnnotation[]` stream
+  passed per file to `PrInlineDiff` (the `annotationsForFileMerged` computed from E1).
+- Modify: `apps/desktop/src/components/PrIntelligencePanel.vue` — a "Pre-review findings"
+  section: confidence-sorted list, per-finding severity + confidence chip, a "Dismiss" action
+  (calls `dismissFinding`), click-to-jump (sets `selectedDiffFile` + `scrollToLine`), and the
+  progress/running indicator. Render `detail` via `useSafeHtml` if it may contain markup.
+- Modify: `apps/desktop/src/components/PrDetailView.vue` + B1 keymap — implement `next-finding`
+  /`prev-finding` (`N`/`P`): cycle the confidence-sorted findings, switch file + scroll to the
+  finding's line, highlight the active finding.
+
+- [x] **Step 1:** `prAnnotations.test.ts` extension: `fromFinding` maps side/line/confidence/id;
+  merged stream keeps CI + AI distinct by `source`.
+- [x] **Step 2:** `usePrPanel-findings-render.test.ts`: merged annotations for a file include
+  both CI and AI entries; dismissing a finding removes it from the stream and the list. (Found
+  while writing this test: findings only ever render when `reviewAiPreReview` is on — even a
+  cache hit is gated by the opt-in setting, not just live compute. Confirmed that's the intended
+  behavior, not a bug, and adjusted the test rather than the code.)
+- [x] **Step 3:** Implemented the Intelligence panel's findings list (jump-to-line, dismiss,
+  confidence chip, running/progress indicator) + `N`/`P` nav in `usePrReviewNav` (extended, not
+  a new file — `next-finding`/`prev-finding` were already-wired no-op cases from B1/C3) +
+  5-locale keys under a new `pr.preReview.*` namespace.
+- [x] **Step 4:** `pnpm test` green (545 tests); `vue-tsc --noEmit` clean (fixed two knock-on
+  type errors: the new `PrIntelligencePanel` props are also required by the legacy, unused-but-
+  still-typechecked `PullRequestPanel.vue` — passed harmless defaults there rather than touching
+  otherwise-dead code; and exported `DiffRowLike` from `usePrReviewNav.ts` for the test's mock
+  typing).
+
+**Done when:** findings show as line-anchored AI annotations + a sorted dismissable list, and
+`N`/`P` cycle through them across files.
+
+**Commit:** `feat(pr-review): render and navigate AI pre-review findings`
+
+---
+
+## PHASE D — PR summary
+
+### Task D1: PR summary block on the Info tab
+
+**Spec D1.** A "Summary" block at the top of the Info tab — what / why / affected areas —
+generated by one LLM pass over the indexed diff + commit titles, cached by `headSha`,
+regenerable on demand, copyable, rendered via `useSafeHtml`.
+
+**Files:**
+- Create: `apps/desktop/src/composables/usePrSummary.ts`:
+  - `buildSummaryPrompt(diffIndex, commitTitles, locale)` → asks for a short structured summary
+    (what / why / affected areas). One `ai.rawPrompt` call.
+  - `generate(ctx): Promise<string>` (markdown or plain; rendered safe).
+  - Commit titles via `gitExec(["log","--format=%s", base..head])` or the forge — prefer local
+    `gitExec` for forge-agnosticism (pattern `useBlameContext.ts`).
+- Modify: `apps/desktop/src/composables/usePrCache.ts` — `summaries: Record<string
+  /*detailKey@headSha*/, { text: string; ts: number }>` + `getSummary`/`setSummary`.
+- Modify: `apps/desktop/src/composables/usePrPanel.ts` — `prSummary` ref, `loadSummary()`
+  (opt-in `settings.reviewAiSummary`, cache-first by `detailKey@headSha`, guarded like C3),
+  `regenerateSummary()` (bypasses cache), triggered when the Info tab opens if enabled.
+- Modify: `apps/desktop/src/components/PrDetailView.vue` (Info tab `:549`) — the Summary block:
+  loading/empty/error states, a Regenerate button, a Copy button, `v-html` via `useSafeHtml`
+  (never `renderBody`).
+
+- [x] **Step 1:** `usePrSummary.test.ts` (7 cases): `generate` returns the model text; commit
+  titles are fetched (with an `origin/<base>..origin/<head>` fallback when the plain range
+  fails) and included in the prompt; empty diff / AI-unavailable → graceful `""`.
+- [x] **Step 2:** `usePrCache-summary.test.ts`: round-trip by `detailKey@headSha`, a different
+  headSha misses, cold-start persistence.
+- [x] **Step 3:** `usePrPanel-summary.test.ts` (4 cases): disabled → no call; cache hit → no
+  call, instant paint; miss → generates + writes through; `regenerateSummary` bypasses the
+  cache and rewrites it.
+- [x] **Step 4:** Info-tab UI (loading/empty-via-not-rendering-at-all/regenerate/copy, `v-html`
+  via `renderMarkdown` — never the hand-rolled `renderBody`) + 5-locale keys under `pr.summary.*`.
+
+**Done when:** an opt-in summary paints at the top of Info, cached by headSha, regenerable,
+copyable, and sanitized.
+
+**Commit:** `feat(pr-review): AI PR summary on the Info tab`
+
+---
+
+## PHASE E2 — Unify the Intelligence pipeline
+
+### Task E2: `useReviewIntelligence` orchestrator
+
+**Spec E2.** One composable orchestrating pre-review (C), summary (D), the migrated hunk
+critique (anchored to lines when possible), and the static `aiFlags` — shared cache, single
+state. `usePrPanel.ts` **composes** it (doesn't absorb its state).
+
+**Files:**
+- Create: `apps/desktop/src/composables/useReviewIntelligence.ts` — composes
+  `usePrPreReview`/`usePrReviewQueue` (C), `usePrSummary` (D), `usePrHunkCritique` (existing),
+  and the static flags logic currently inline in `PrIntelligencePanel.vue:110-145`
+  (extract `computeStaticFlags(diffFiles): LineAnnotation[]` into this composable, `source:
+  "static"`, anchored to a line where the flag maps to one). Exposes a single reactive surface:
+  `{ findings, summary, hunkCritique, staticFlags, mergedAnnotationsForFile(path),
+  progress, running, dismissFinding, regenerateSummary, requestHunkCritique }`.
+- Migrate hunk critique anchoring: `usePrHunkCritique` returns a hunk-level verdict; wrap it so
+  a critique becomes a `LineAnnotation` anchored to the hunk's first changed line (best-effort)
+  in addition to the existing inline panel — keep the existing per-hunk button UX working.
+- Refactor: `apps/desktop/src/composables/usePrPanel.ts` — replace the ad-hoc pre-review/summary
+  refs added in C3/D1 with a single `const intel = useReviewIntelligence(...)`; re-export what
+  the components need. **Net line count of `usePrPanel` should not grow** — the intel state
+  moves out. (usePrPanel is 1111 lines; this is the "compose, don't absorb" requirement.)
+- Refactor: `apps/desktop/src/components/PrIntelligencePanel.vue` — consume
+  `staticFlags`/`findings` from the unified surface instead of computing `aiFlags` locally.
+- Refactor: `apps/desktop/src/components/PrInlineDiff.vue` — annotations prop is fed by
+  `mergedAnnotationsForFile` (CI + AI + static + critique), one stream.
+
+- [x] **Step 1:** `useReviewIntelligence.test.ts` (7 cases): the merged annotation stream for a
+  file (exercised through `usePrPanel`, its real caller) contains CI + AI entries with correct
+  `source`; `computeStaticFlags` reproduces the pre-E2 `aiFlags` thresholds (big-file, export
+  removal, config/migration file, big hunk, clean diff) as `LineAnnotation`s. **Critique** entries
+  are not in the merged stream (see Step 2 note) — the test title's "+critique" is scoped down
+  accordingly.
+- [x] **Step 2:** Implemented `useReviewIntelligence.ts` (pre-review C1-C4, summary D1, static
+  flags ported verbatim-logic from `PrIntelligencePanel.vue`, merged `LineAnnotation` stream).
+  **Adapted from plan:** hunk-critique anchoring was *not* wired into the merged stream.
+  `usePrHunkCritique`'s state (`critiqueResults`, per-hunk open/loading) lives entirely inside
+  `PrInlineDiff.vue`'s own local script — decision #3 explicitly keeps its existing per-hunk
+  button UX "in parallel", and there's no live data path from that local, per-component state
+  into a shared composable without either (a) hoisting that state up to `usePrPanel`/
+  `useReviewIntelligence` (a real UX-affecting rewire, not what decision #3 asked for) or
+  (b) adding a dead, untriggered wrapper function. Neither seemed right to force through
+  silently, so this is flagged as a gap rather than a plan violation: a future task can hoist
+  the critique state if merging it into the gutter overlay is wanted.
+- [x] **Step 3:** Refactored `usePrPanel` to compose it (`const intel = useReviewIntelligence(...)`,
+  re-exporting its surface under the same public names so `PrDetailView.vue`/
+  `PrIntelligencePanel.vue` bindings didn't need to change). Full existing suite green — no
+  behavior regressions. `usePrPanel.ts`: 219 lines removed / 24 added net (`git diff --stat`) —
+  state moved out, confirming "compose, don't absorb."
+- [x] **Step 4:** Refactored `PrIntelligencePanel.vue` to consume `staticFlags` (new prop) from
+  the unified surface instead of computing `aiFlags` locally; `PrInlineDiff.vue` needed no
+  change — it already consumed `usePrPanel.mergedAnnotationsByFile` (C4), which now sources
+  from `useReviewIntelligence` transparently. `pnpm test` green (566 tests).
+
+**Done when:** all AI/static/CI signals flow through one composable and one merged annotation
+stream; `usePrPanel` composes rather than owns that state.
+
+**Commit:** `refactor(pr-review): unify AI + static + CI signals in useReviewIntelligence`
+
+---
+
+## PHASE F — Multi-forge: GitLab review completion
+
+### Task F1: GitLab real reviews (inline batch, listReviews, createComment, getFileHistory)
+
+**Spec F1.** Complete the biggest stub gap.
+
+**Files:**
+- Add MR diff refs source: Rust command
+  `apps/desktop/src-tauri/src/commands/gitlab.rs` `gl_mr_diff_refs(cwd, iid) -> { base_sha,
+  start_sha, head_sha }` (reads the MR JSON `diff_refs`; the fetch pattern already exists in
+  `gl_mr_to_detail`). Register in `lib.rs`; wrapper `glMrDiffRefs` in `backend-gitlab.ts`;
+  `dev-server.mjs` route `/api/gl-mr-diff-refs` (parity). (Alternatively surface `headSha` etc.
+  via Task 0's detail if `diff_refs` is added there — but `base_sha`/`start_sha` are needed for
+  positioning, so a dedicated refs command is cleanest.)
+- Modify: `apps/desktop/src/composables/forge/GitLabProvider.ts`
+  - `submitReview` (`:221-249`): after the approve/note handling, if `opts.comments?.length`,
+    fetch diff refs once via `glMrDiffRefs`, then for each pending comment call
+    `glMrCreateDiscussion` with correct `baseSha/startSha/headSha` and old/new-side anchoring
+    (`oldLine` for LEFT, `newLine` for RIGHT). Stop synthesizing a fake `PrReview` when real
+    discussions were created — return a representative review reflecting the event.
+  - `createComment` (`:177-194`): remove the `as any` casts — read `base_sha/start_sha/head_sha`
+    from a typed `CreatePrCommentParams` extension (add optional `base_sha?/start_sha?/head_sha?`
+    to the param type in `backend-pr.ts`, or fetch via `glMrDiffRefs` when absent) and pass
+    `oldLine`/`newLine` from the comment's side.
+  - `listReviews` (`:217`): keep approvals, but also represent COMMENTED / CHANGES_REQUESTED by
+    scanning MR notes for the review markers this provider writes (the `**Changes requested:**`
+    prefix at `:237`) — return a merged, deduped `PrReview[]` (approvals + note-derived
+    verdicts), not approvals-only.
+  - `getFileHistory` (`:265-279`): implement the real heuristic — fetch MR notes once
+    (`glMrNotes`), count notes mentioning each path, collect reviewers, last comment — instead
+    of the zeroed placeholder.
+
+- [x] **Step 1:** `gl_mr_diff_refs` is Tauri-only (no dev-server route — consistent with every
+  other GitLab command in this codebase: "GitLab repos are only accessible in the native Tauri
+  app context"). Not added to the parity set: it needs a live MR, same documented no-op as
+  Task 0/B4's GitHub-side commands.
+- [x] **Step 2:** `GitLabProvider.test.ts` extended (9 new cases): `submitReview` with
+  `opts.comments` fetches refs once and calls `glMrCreateDiscussion` per comment with correct
+  side anchoring; `createComment` passes typed SHAs (no `as any`) and the right old/new line;
+  `listReviews` surfaces a note-derived CHANGES_REQUESTED alongside an approval; `getFileHistory`
+  counts notes per path (and returns empty placeholders before any PR has loaded — see Step 4
+  note on the `prNumber`-less interface).
+- [x] **Step 3:** Implemented `gl_mr_diff_refs` (Rust) + `glMrDiffRefs` wrapper; `cargo build`
+  green; `pnpm test:parity` — no-op (see Step 1).
+- [x] **Step 4:** Implemented the four provider methods. **Adapted from plan:**
+  `getFileHistory(cwd, paths)`'s `ForgeProvider` signature carries no `prNumber` (shared across
+  all forges; GitHub's version is repo-wide via its own dev-server route), so a real per-MR
+  GitLab heuristic needs a `prNumber` from somewhere else — used the most recently opened MR
+  (`_lastIid`, set by `getPR`) as the scope, empty history until a PR has loaded. Also added a
+  second note-body marker (`**Review:**`) for COMMENT-event review submissions going forward
+  (the existing `**Changes requested:**` marker only covered REQUEST_CHANGES) so `listReviews`
+  can deterministically derive both verdicts — not retroactive for already-posted notes.
+
+**Done when:** on GitLab, a batch review posts real inline discussions with correct anchors,
+`listReviews` reflects comment/changes-requested verdicts, `createComment` is type-clean, and
+`getFileHistory` returns real counts.
+
+**Commit:** `feat(pr-review): complete GitLab review methods (inline batch, reviews, history)`
+
+### Task F2: Azure updateComment/deleteComment — honest error + UI hide
+
+**Spec F2.** Azure `updateComment`/`deleteComment` currently throw at runtime. Either implement
+if trivial, or keep as `ForgeNotImplementedError` with UI that hides the action (never a crash).
+Bitbucket/Azure inline comments stay out of scope.
+
+**Files:**
+- Modify: `apps/desktop/src/composables/forge/AzureProvider.ts` — make `updateComment`/
+  `deleteComment` throw `ForgeNotImplementedError("azure", …)` (typed, not a bare runtime
+  throw) unless the Azure REST edit/delete is trivial to wire (a `az`/REST call analogous to
+  existing Azure comment creation) — prefer implementing if the endpoint mirrors an existing
+  one; otherwise the typed error.
+- Modify: `apps/desktop/src/components/PrCommentThread.vue` (or wherever edit/delete buttons
+  live) — hide the edit/delete affordance when the active forge doesn't support it. Add a
+  capability signal: `usePrPanel` exposes `forgeSupportsCommentEdit`/`Delete` computed
+  (`forge.value.name !== "azure"` for now, or a capability probe), consumed by the thread.
+- Ensure `handleEditComment`/`handleDeleteComment` (`usePrPanel.ts:824-840`) swallow
+  `ForgeNotImplementedError` into a no-op/hidden action rather than the error banner (same
+  pattern as `convertDraftToReady` `:783-784`).
+
+- [x] **Step 1:** `AzureProvider.test.ts`: `updateComment`/`deleteComment` throw
+  `ForgeNotImplementedError` (name asserted), not a generic `Error` (unless implemented — then
+  assert the backend call).
+- [x] **Step 2:** `usePrPanel` capability computed test: edit/delete hidden for Azure, shown for
+  GitHub/GitLab.
+- [x] **Step 3:** Implement + hide UI affordance; green.
+
+**Adapted from plan:** `AzureProvider.updateComment`/`deleteComment` already threw a typed
+`ForgeNotImplementedError` (done in an earlier release, before this session) — Step 1 added test
+coverage only, no production change there. The rest of F2 was net-new: `usePrPanel` gained
+`forgeSupportsCommentEdit`/`forgeSupportsCommentDelete` computeds (`forge.value.name !== "azure"`,
+as specified), `handleEditComment`/`handleDeleteComment` now swallow `ForgeNotImplementedError`
+the same way `handleDismissReview`/`handleRequestReviewers` already did, and the capability flows
+down as `canEditComments`/`canDeleteComments` props: `PrDetailView.vue` → `PrInlineDiff.vue` →
+`PrCommentThread.vue` (`canEdit`/`canDelete`, default `true`), which hides the ✏️/🗑 buttons
+individually rather than the whole `.pct-actions` block, so a forge that supports one but not the
+other degrades correctly too.
+
+**Done when:** Azure never crashes on edit/delete — the actions are hidden or cleanly report
+unsupported.
+
+**Commit:** `fix(pr-review): honest Azure comment edit/delete capability, no runtime crash`
+
+---
+
+## PHASE G — Finalization
+
+### Task G: i18n verification + CHANGELOG
+
+**Files:**
+- All 5 locale files (`apps/desktop/src/locales/{en,fr,es,pt-br,zh-cn}.ts`) — verify every key
+  added across tasks B–F exists in all five, with real translations (not English placeholders).
+- `CHANGELOG.md` (repo root) — add a single `## [Unreleased]` entry (or append to the existing
+  one) grouped by `### Added / Changed / Fixed`, covering: lazy diff parse + virtualization +
+  3-call revalidation; keyboard keymap; viewed-file state; pending-review surfacing; dismiss/
+  request-reviewers; AI pre-review (opt-in, confidence, cap, dismissal memory); PR summary;
+  unified Intelligence pipeline; GitLab review completion; Azure comment capability fix.
+  **No version bump. No `website/changelog.md` edit** (both are tag-time, per AGENTS.md).
+
+- [x] **Step 1:** Run a locale-key audit (grep each new `t('…')`/`LocaleKey` against all five
+  files, or a small script) — zero missing keys; `dev:web` shows no missing-key warnings.
+- [x] **Step 2:** Write the `[Unreleased]` CHANGELOG entry.
+- [x] **Step 3:** Full green gate: `pnpm -r test` + `cd apps/desktop && pnpm test` +
+  `pnpm test:parity` + `cd packages/core && pnpm test`.
+
+**Adapted from plan:** the locale-key audit was done with a small ad-hoc brace-tracking script
+(structural key-path diff across all 5 files) rather than grepping every individual `t('…')`
+call site — zero missing/orphan keys in fr/es/pt-BR/zh-CN vs. en, and spot checks of the keys
+added across B–F (`help.keyboardShortcuts.pr*`, `settings.reviewAi.*`, `pr.viewed.*`,
+`pr.reviews.*`, `pr.preReview.*`, `pr.summary.*`) confirm real (non-English) translations, not
+placeholders. One pre-existing `// TODO: translate` remains in `pt-BR.ts` (`common.stash...
+dropAllTitle`) — unrelated to this chantier (stash UI, not PR review), left untouched.
+
+**Done when:** all 5 locales complete, CHANGELOG updated (Unreleased only), every suite green.
+
+**Commit:** `docs(changelog): PR Review 2.0 Unreleased entry + i18n sync`
+
+---
+
+## Success metrics checklist (spec §3 — verify before merge)
+
+- [ ] Detail open = 3 forge calls on the hot path (was 6). (Task A3 test.)
+- [ ] 50-file PR parses only the selected file. (Task A1 test.)
+- [ ] 5 000-line file diff DOM is bounded. (Task A2 manual perf note in PR.)
+- [ ] Full review drivable via `J/K/⇧J/⇧K/V/⇧V/T/C/N/P/⌘Enter`, resolver unit-tested. (B1/C4.)
+- [ ] AI findings ≤ cap, all ≥ threshold, line-anchored, dismissable with memory. (C2/C4.)
+- [ ] Pipeline opt-in, zero calls when off, aborts on PR switch, never recomputes at constant
+  headSha. (C3 test.)
+- [ ] `pnpm -r test` green, parity green for new commands, all 5 locales complete. (Task G.)
+
+## Open decisions for the human checkpoint
+
+1. **Viewed-state invalidation granularity (B2):** the plan invalidates viewed state at the
+   whole-PR level on any headSha change (simplest, matches "re-push resets viewed" honestly).
+   Per-file blob-SHA granularity (only changed files revert) is noted as a follow-up — confirm
+   the coarser behavior is acceptable for v3.6.0.
+2. **`gl_mr_diff_refs` vs. extending Task 0 detail (F1):** the plan adds a dedicated refs
+   command because inline positioning needs `base_sha` + `start_sha`, not just `head_sha`.
+   Confirm we don't instead want to fold all three SHAs into `PullRequestDetail` in Task 0.
+3. **Hunk-critique anchoring (E2):** migrating the existing hunk-level verdict to a
+   line-anchored `LineAnnotation` is best-effort (anchors to the hunk's first changed line).
+   Confirm keeping the existing per-hunk button UX in parallel is desired (plan assumes yes).
+4. **Azure comment edit/delete (F2):** plan defaults to a typed `ForgeNotImplementedError` +
+   hidden UI unless the REST endpoint is trivial. Confirm we don't require a full Azure
+   implementation in this release.
diff --git a/docs/superpowers/specs/2026-07-09-v3.6.0-pr-review-2-target-ux.md b/docs/superpowers/specs/2026-07-09-v3.6.0-pr-review-2-target-ux.md
new file mode 100644
index 00000000..6f0b6b6c
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-09-v3.6.0-pr-review-2-target-ux.md
@@ -0,0 +1,107 @@
+# v3.6.0 — PR Review 2.0 : spec UX cible (benchmark-driven)
+
+> Livrable n°1 du chantier v3.6.0 (roadmap.md). Synthèse de deux études menées le 2026-07-09 :
+> un audit exhaustif de la surface review actuelle (baseline v2.24.0, refs `file:line` sur
+> `feat/pr-review-2` @ 6c394d0) et un benchmark concurrentiel (GitKraken, Tower, Graphite,
+> GitButler ; Greptile v4, CodeRabbit, Copilot code review). Cette spec fixe le périmètre et
+> les décisions d'UX ; le plan d'implémentation détaillé vit dans `docs/superpowers/plans/`.
+
+---
+
+## 1. Verdict du benchmark
+
+### Baseline GitWand (audit code)
+
+| Axe | État actuel | Gap |
+|---|---|---|
+| Time-to-first-comment | Detail = `Promise.all` de 6 appels à chaque open **et** à chaque tick du poll 5 min (`usePrPanel.ts:568-575`) ; diff fetché+parsé d'un bloc, synchrone main-thread (`:631-643`, parse `:319-365`) | 3 des 6 appels sont différables par tab (`gitFileCount`, `getCIChecks`, `listIssueComments`) ; aucun résumé de PR ; l'IA est on-demand uniquement |
+| Navigation grosses PRs | Rendu un-fichier-à-la-fois mais `PrInlineDiff.vue` rend **toutes** les lignes du fichier (`:336`, `:390`), zéro virtualization ; aucun viewed-state ; aucun raccourci clavier (Escape seulement) | Lag scroll sur gros fichiers ; aucun moyen de savoir où on en est dans une PR 50+ fichiers |
+| Signal/bruit IA | `usePrHunkCritique.ts` : critique LLM par hunk, on-demand, verdict prose sans confiance ni ancre ligne, cache éphémère composant ; `aiFlags` de l'onglet Intelligence = heuristiques statiques (aucun LLM) ; 3 morceaux IA déconnectés | Pas de pré-review, pas de score de confiance, pas de seuil, pas de cache partagé, pas de surface settings unique |
+
+### État de l'art 2026 (patterns retenus, sourcés)
+
+1. **Virtualization du diff** = table stakes (GitHub l'a shippée par défaut le 2026-01-22).
+2. **Keymap GitHub Files-changed** = standard de facto : `J`/`K` (hunk/fichier suivant/précédent), `V` (viewed), `Shift+V` (masquer les viewed), `T` (filtre fichiers), `?` (aide).
+3. **Confiance par finding + seuil utilisateur** (Greptile : ~90 % = bug sûr, ~50-60 % = piste à vérifier).
+4. **Cap délibéré du volume de commentaires** (Copilot : ~5,1 commentaires/review tenus constants ; 71 % « actionnables » comme métrique nord).
+5. **Étage de vérification avant publication** (CodeRabbit : chaque suggestion validée séparément avant d'être postée) — le vrai mécanisme anti-bruit.
+6. **Learn-from-rejections** (CodeRabbit Learnings) : les dismissals répétés suppriment la classe de findings.
+7. **Résumé de PR en tête** (what/why/affected areas) pour réduire le time-to-understanding.
+8. **Entrée par inbox triée** (Graphite « Needs your review », GitKraken Launchpad) — GitWand a déjà Today.
+9. **Benchmark honnête** : réutiliser la *méthodologie* Greptile (PRs de bug-fix reproduites, « caught » = commentaire ligne explicite, catch-rate toujours apparié au noise-rate), jamais les chiffres vendeurs (82 % self-run vs 45 % en re-run indépendant).
+
+**Positionnement GitWand** : local-first, opt-in, privé, fusionné au moteur de merge — aucun reviewer SaaS ne l'offre. La v3.6.0 vise la parité UX (perf + clavier + viewed) **plus** un pipeline IA local honnête (confiance + seuil + cap), pas la course au catch-rate.
+
+---
+
+## 2. Périmètre v3.6.0
+
+### In scope (cette PR)
+
+**A. Performance rebuild**
+- **A1 — Parse lazy par fichier** : `getPRDiff` reste un fetch unique, mais la string unifiée est découpée par en-têtes `diff --git` (indexation légère) et chaque fichier n'est **parsé** que lorsqu'il est sélectionné (cache par fichier). Supprime le parse bloquant du PR entier à l'open. (Le vrai fetch par fichier et le Web Worker restent v3.9.0.)
+- **A2 — Virtualization des lignes du diff** : `PrInlineDiff.vue` passe sur `@tanstack/vue-virtual` (déjà en dépendance) via un composable partagé `useVirtualRows` lifté du pattern hauteur-variable de `CommitLog.vue` (`useVirtualizer` + `measureElement`). Budget : DOM borné quel que soit le fichier ; fallback rendu complet sous un seuil (< 300 lignes) pour préserver find/select natif.
+- **A3 — Revalidation amincie** : cœur = `getPR + listComments + listReviews` (3 appels) à l'open et au poll ; `getCIChecks` déféré au tab Checks/Diff, `gitFileCount` aux loaders lazy Intelligence, `listIssueComments` au tab Info. Écart mesurable : 6 → 3 appels sur le chemin chaud.
+
+**B. Review flow (keyboard-first + viewed)**
+- **B1 — Keymap GitHub-standard**, scopée au tab Diff, via un resolver pur testé unitairement (pattern `resolveTerminalShortcut` de `useTerminalSessions.ts:9-20`) : `J`/`K` hunk suivant/précédent (franchit les frontières de fichiers), `⇧J`/`⇧K` fichier suivant/précédent, `V` toggle viewed, `⇧V` masquer/afficher les viewed, `T` filtre fichiers, `C` commenter le hunk courant, `?` aide. Guard focus strict : inactif dans tout input/textarea/palette. Réutilise la machinerie de saut de hunk de `DiffViewer.vue:180-194`. Raccourcis ajoutés à `HelpView.vue`.
+- **B2 — Viewed-file state** : persistance **client** par PR dans le cache SWR (`usePrCache`), clé `repo#number`, invalidée par fichier quand le head SHA change (re-push = fichiers modifiés redeviennent non-viewed). Checkbox par fichier dans la sidebar diff + barre de progression « X/N viewed » + option masquer les viewed. `SubmitReviewOptions` étendu d'un champ optionnel `viewedFiles?: string[]` (transport forge optionnel ; GitHub n'a pas d'API native → source de vérité = client).
+- **B3 — Pending review surfacé** : badge compteur persistant (les `draftReviewComments` survivent déjà au switch de tab, le badge manque) + reprise après fermeture/réouverture du detail (draft persisté dans le cache SWR) + `⌘Enter` submit review.
+- **B4 — Dismiss review + request reviewers** : nouvelles méthodes forge `dismissReview` et `requestReviewers` (GitHub réel ; GitLab réel si l'API le permet, sinon erreur honnête `ForgeNotImplementedError` — jamais de dégradation silencieuse) ; UI dans le tab Info (liste reviews + picker reviewers réutilisant `listReviewerCandidates`, déjà réel sur les 4 forges).
+
+**C. AI pre-review pass (Greptile-style, local-first)**
+- **C1 — Pipeline multi-hop local**, calculé en arrière-plan à l'ouverture d'une PR (opt-in) :
+  1. *Hop diff* : hunks du PR (réutilise le parse A1).
+  2. *Hop dépendances* : extraction des specifiers d'imports des fichiers touchés (`tryResolveImportConflict`/parse de `packages/core/src/resolvers/imports.ts` — extraction seule, pas de graphe : le graphe résolu est explicitement v4.0) et croisement avec les chemins du repo pour signaler « ce fichier modifié est importé par N fichiers du diff ».
+  3. *Hop history* : blame des lignes modifiées via `git_blame` (`read.rs:1285`) + message du dernier commit touchant ces lignes (pattern `useBlameContext.ts`, GitHub-indépendant, marche sur les 4 forges).
+  4. *Findings* : prompt structuré → JSON strict `{path, line, side, severity, confidence: 0-100, title, detail}` ; parse défensif (récup fence/brace comme `usePrHunkCritique.ts:78-99`).
+- **C2 — Signal/bruit** : seuil de confiance utilisateur (défaut 60), **cap top-N par confiance** (défaut 15 findings/PR), et **mémoire locale des rejets** : un finding dismissé persiste par repo (classe = `path glob + title normalisé`) et les occurrences futures similaires sont masquées sous le seuil.
+- **C3 — Exécution** : file de travail avec concurrence bornée (1 appel CLI à la fois — chaque appel = spawn subprocess), annulable (switch de PR / fermeture), gated visibilité comme le poll existant. Cache SWR par `repo#number@headSha` : jamais recalculé tant que le head ne bouge pas. Statut visible (« Pré-review : 4/12 fichiers… ») avec findings affichés au fil de l'eau.
+- **C4 — Rendu** : findings ancrés ligne dans le diff via l'overlay CI-annotations généralisé (voir E1), + liste triée par confiance dans le panneau Intelligence, navigation finding-suivant/précédent au clavier (`N`/`P`).
+
+**D. PR summary**
+- **D1** : bloc « Résumé » en tête du tab Info — *quoi / pourquoi / zones affectées* — généré par le même pipeline (une passe LLM sur le diff indexé + titres de commits), caché par `headSha`, régénérable à la demande. Sert de handoff de review (copiable). Rendu via `useSafeHtml.ts` (jamais le `renderBody` hand-rolled actuel).
+
+**E. Pipeline Intelligence unifié**
+- **E1 — Type partagé `LineAnnotation`** avec `source: "ci" | "ai" | "static"`, sévérité ouverte (préserve confiance/sévérité IA au lieu de la normalisation 3-niveaux de `mapAnnotation`), matching des deux côtés old/new (le side LEFT/RIGHT des comments existe déjà comme modèle). `PrInlineDiff` consomme un flux mergé CI + IA + flags statiques, icônes/labels distincts par source.
+- **E2 — Un composable `useReviewIntelligence`** qui orchestre pré-review (C), summary (D), critique de hunk existante (migrée dessus, ancrée ligne quand possible) et `aiFlags` statiques — cache partagé, état unique. `usePrPanel.ts` (1111 lignes) le **compose**, n'absorbe pas son état.
+- **E3 — Une surface settings** : section unique « Review AI » dans Settings (provider hérité de `useAIProvider`, opt-in pré-review, seuil de confiance, cap, opt-in summary) — ajoutée à `AppSettings` (`useSettings.ts`) **et** `SettingsPanel.vue` (règle de sync).
+
+**F. Multi-forge : GitLab review complet**
+- **F1** : combler le plus gros stub gap — `submitReview` avec vrais commentaires inline batch (discussions API, ancres old/new correctes, plus d'objet `PrReview` synthétisé), `listReviews` réel (représenter COMMENTED/CHANGES_REQUESTED, pas approvals-only), `createComment` inline sans `as any` (ancre old-side incluse), `getFileHistory` réel.
+- **F2** : Azure `updateComment`/`deleteComment` qui **throw** au runtime : soit implémentés si triviaux, soit gardés en `ForgeNotImplementedError` avec UI qui masque l'action (jamais de crash). Bitbucket/Azure inline comments = hors périmètre (roadmap : « Bitbucket/Azure follow »).
+
+### Out of scope (explicite)
+
+- Fetch réseau du diff par fichier + parse en Web Worker → **v3.9.0** (même hot-path, dépend de comlink).
+- Graphe d'imports résolu / reverse-deps / blast-radius → **v4.0.0** (le hop dépendances de C1 reste de l'extraction+matching léger).
+- Moved-code-as-moved (GitKraken), diagrammes dans le summary (CodeRabbit Atlas) → backlog, notés en veille.
+- Review par commit (GitButler) / vue changeset multi-commits → **v3.12.0** (Combined Diffs).
+- Complétion review Bitbucket/Azure inline → suite de F, version ultérieure.
+- Harnais de benchmark automatisé type Greptile → réutilisé comme *méthodologie* de validation manuelle ici ; l'outillage viendra avec v3.7.0 (même moteur pointé sur l'index).
+
+---
+
+## 3. Métriques de succès (à vérifier avant merge)
+
+| Métrique | Cible |
+|---|---|
+| Appels réseau à l'ouverture d'un detail PR (chemin chaud) | 6 → 3 |
+| Parse du diff à l'open d'une PR 50+ fichiers | fichier sélectionné uniquement (plus de parse du PR entier) |
+| Nœuds DOM du diff d'un fichier 5 000 lignes | borné par la virtualization (~visible + overscan), scroll fluide |
+| Review complète possible au clavier seul | J/K/⇧J/⇧K/V/⇧V/T/C/N/P/⌘Enter, testés unitairement via le resolver |
+| Findings IA affichés | ≤ cap (déf. 15), tous ≥ seuil de confiance, ancrés ligne, dismissables avec mémoire |
+| Pipeline IA | opt-in, zéro appel si désactivé, annulé au switch de PR, jamais recalculé à headSha constant |
+| Régression zéro | `pnpm -r test` vert, parité dev:web pour toute nouvelle commande, i18n 5 locales complètes |
+
+---
+
+## 4. Contraintes d'implémentation (rappel audit)
+
+- Toute nouvelle commande Tauri → wrapper `backend*.ts` + route `dev-server.mjs` dans la même PR (parité dev:web).
+- Aucun `invoke()` direct hors `backend.ts` ; aucun interval inconditionnel (tout poll IA gated visibilité + opt-in).
+- Strings user-visible → clés dans les 5 locales (`en`, `fr`, `es`, `pt-BR`, `zh-CN`).
+- Nouveaux settings → `AppSettings` + `SettingsPanel.vue` dans le même commit.
+- HTML dérivé de contenu user/LLM → `useSafeHtml.ts` (DOMPurify).
+- `packages/core` reste browser-safe (le pipeline IA vit côté desktop ; seule l'extraction d'imports est consommée depuis core).
+- Fichiers pivots : `usePrPanel.ts`, `usePrHunkCritique.ts`, `useAIProvider.ts`, `usePrCache.ts`, `composables/forge/{types,GitLabProvider}.ts`, `components/{PrDetailView,PrInlineDiff,PrIntelligencePanel}.vue`, `utils/backend-pr.ts`, `dev-server.mjs`, `src-tauri/src/commands/read.rs`.
diff --git a/packages/core/src/__tests__/resolvers/import-extract.test.ts b/packages/core/src/__tests__/resolvers/import-extract.test.ts
new file mode 100644
index 00000000..7cb6c91a
--- /dev/null
+++ b/packages/core/src/__tests__/resolvers/import-extract.test.ts
@@ -0,0 +1,60 @@
+/**
+ * extractImportSources (C0, v3.6.0) — pure extraction of import module
+ * specifiers from arbitrary file content, for the PR-review dependency hop
+ * (C1). Extraction only, no resolved graph (that's v4.0).
+ */
+import { describe, it, expect } from "vitest";
+import { extractImportSources } from "../../resolvers/imports.js";
+
+describe("extractImportSources", () => {
+  it("extracts a named import source", () => {
+    expect(extractImportSources(`import { useState } from 'react';`)).toEqual(["react"]);
+  });
+
+  it("extracts a relative import source", () => {
+    expect(extractImportSources(`import { helper } from '../utils';`)).toEqual(["../utils"]);
+  });
+
+  it("extracts a side-effect import", () => {
+    expect(extractImportSources(`import 'core-js/stable';`)).toEqual(["core-js/stable"]);
+  });
+
+  it("extracts a CommonJS require", () => {
+    expect(extractImportSources(`const fs = require('fs');`)).toEqual(["fs"]);
+  });
+
+  it("extracts an `export … from` re-export", () => {
+    // Braced named re-exports (`export { foo } from …`) aren't matched by
+    // the shared RE_EXPORT_FROM regex — a pre-existing limitation of the
+    // conflict-resolution regex this function reuses, not introduced here;
+    // `export * from …` is the form it does support.
+    expect(extractImportSources(`export * from './foo';`)).toEqual(["./foo"]);
+  });
+
+  it("dedupes repeated sources across multiple statements", () => {
+    const content = [
+      `import { a } from 'react';`,
+      `import { b } from 'react';`,
+      `import type { C } from 'react';`,
+    ].join("\n");
+    expect(extractImportSources(content)).toEqual(["react"]);
+  });
+
+  it("ignores non-import lines (comments, code, blank lines)", () => {
+    const content = [
+      `// a comment mentioning from 'nope'`,
+      `function foo() { return 1; }`,
+      ``,
+      `import { real } from 'real-module';`,
+    ].join("\n");
+    expect(extractImportSources(content)).toEqual(["real-module"]);
+  });
+
+  it("returns [] for content with no imports", () => {
+    expect(extractImportSources("const x = 1;\nfunction f() {}\n")).toEqual([]);
+  });
+
+  it("returns [] for empty content", () => {
+    expect(extractImportSources("")).toEqual([]);
+  });
+});
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 32e8eb3a..2eb077f0 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -65,7 +65,7 @@ export { tryResolveMarkdownConflict, parseSections, extractFrontmatter } from ".
 
 // Phase 7.3b — Résolveurs supplémentaires (YAML, imports TS/JS, Vue SFC, CSS)
 export { tryResolveYamlConflict } from "./resolvers/yaml.js";
-export { tryResolveImportConflict, isImportBlock } from "./resolvers/imports.js";
+export { tryResolveImportConflict, isImportBlock, extractImportSources } from "./resolvers/imports.js";
 export { tryResolveVueConflict, parseSfcBlocks } from "./resolvers/vue.js";
 export { tryResolveCssConflict, parseCssRules } from "./resolvers/css.js";
 
diff --git a/packages/core/src/resolvers/imports.ts b/packages/core/src/resolvers/imports.ts
index 771e2aef..14217372 100644
--- a/packages/core/src/resolvers/imports.ts
+++ b/packages/core/src/resolvers/imports.ts
@@ -131,6 +131,24 @@ function parseImport(line: string): ImportStatement {
   return { raw: t, source: "", kind: "unknown", names: [], isType: false };
 }
 
+/**
+ * Extract the deduped list of module specifiers imported by `content` (C0,
+ * v3.6.0 — the PR-review dependency hop's extraction step; the resolved
+ * import *graph* is explicitly out of scope until v4.0). Pure string work,
+ * reuses the same regexes/`parseImport` as the conflict resolver above.
+ * Scans every line of arbitrary file content (not just a contiguous import
+ * block) — non-import lines are skipped, never throw.
+ */
+export function extractImportSources(content: string): string[] {
+  const seen = new Set<string>();
+  for (const line of content.split("\n")) {
+    if (!isImportLike(line)) continue;
+    const stmt = parseImport(line);
+    if (stmt.source) seen.add(stmt.source);
+  }
+  return [...seen];
+}
+
 // ─── Merge engine ─────────────────────────────────────────
 
 /** Résultat du merge d'imports */