From 6f5dc40f515b33d523682e1d8fc484233f63c641 Mon Sep 17 00:00:00 2001
From: Dean Stratakos <29683763+dastratakos@users.noreply.github.com>
Date: Sat, 17 Oct 2026 02:12:28 +0000
Subject: [PATCH 1/7] feat(service,features,desktop): comment on an agent's
 pull request from the foot of its Conversation

The Conversation ends in a comment box, as GitHub's own does: Markdown
with Write and Preview, sent as a new `comment` action on the
member-writes seam (`addComment` on the pull request), so GitHub hears it
as the member on their own sign-in, never the Luke GitHub App. Once
GitHub takes it the box lets its words go and the conversation is read
again; a refusal stands under the box in GitHub's words, the words kept.

The review panel's Write and Preview move into `markdown-field.tsx`,
which both now draw.

Co-authored-by: luke-agent[bot] <339870089+luke-agent[bot]@users.noreply.github.com>
---
 apps/desktop/src/renderer/styles/tasks.css    | 33 ++++++-
 .../tasks/agent-pull-request-tab.test.ts      | 95 +++++++++++++++++++
 .../renderer/tasks/agent-pull-request-tab.tsx | 15 ++-
 .../src/renderer/tasks/markdown-field.tsx     | 89 +++++++++++++++++
 .../tasks/pull-request-comment-box.tsx        | 69 ++++++++++++++
 .../renderer/tasks/pull-request-review.tsx    | 59 ++----------
 .../renderer/tasks/pull-request-writes.tsx    |  1 +
 ...ingAgentPullRequestActionParamsSchema.json | 20 ++++
 ...e-wire-pullRequestActionRequestSchema.json | 20 ++++
 .../features/src/pull-request-write-wire.ts   |  8 +-
 .../src/agents/coding-agents-app.test.ts      | 28 ++++++
 .../service/src/agents/coding-agents-app.ts   |  7 +-
 .../service/src/github/pull-request-writes.ts | 15 +++
 13 files changed, 402 insertions(+), 57 deletions(-)
 create mode 100644 apps/desktop/src/renderer/tasks/markdown-field.tsx
 create mode 100644 apps/desktop/src/renderer/tasks/pull-request-comment-box.tsx

diff --git a/apps/desktop/src/renderer/styles/tasks.css b/apps/desktop/src/renderer/styles/tasks.css
index 3a64397f08..37d45383cd 100644
--- a/apps/desktop/src/renderer/styles/tasks.css
+++ b/apps/desktop/src/renderer/styles/tasks.css
@@ -1847,14 +1847,16 @@
   color: var(--luke-color-text-muted);
 }
 
-.pull-request-review-body {
+/* Words sent to GitHub as Markdown (`markdown-field.tsx`): Write and
+   Preview over the field, the preview drawn in the field's own box. */
+.markdown-field {
   display: flex;
   flex-direction: column;
   align-items: flex-start;
   gap: var(--luke-space-8);
 }
 
-.pull-request-review-preview {
+.markdown-field-preview {
   box-sizing: border-box;
   width: 100%;
   min-height: 96px;
@@ -1865,7 +1867,7 @@
   border-radius: var(--luke-radius-10);
 }
 
-.pull-request-review-preview > p:only-child {
+.markdown-field-preview > p:only-child {
   margin: 0;
 }
 
@@ -2547,6 +2549,31 @@ button.pull-request-check:hover {
   color: var(--luke-color-text);
 }
 
+/* The comment box at the foot of the Conversation
+   (`pull-request-comment-box.tsx`): the words with their preview, GitHub's
+   refusal under them, and Comment at the row's end. */
+.pull-request-comment-box {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-8);
+}
+
+.pull-request-comment-note {
+  margin: 0;
+  color: var(--text-secondary);
+  font-size: 12px;
+}
+
+.pull-request-comment-note .failure-note-words {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.pull-request-comment-foot {
+  display: flex;
+  justify-content: flex-end;
+}
+
 /* The earlier entries a read left on GitHub, counted where they would stand. */
 .pull-request-earlier {
   margin: 0 0 var(--luke-space-8);
diff --git a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
index f72daab913..d099f51efe 100644
--- a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
+++ b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
@@ -2534,3 +2534,98 @@ test("a review thread on its line in Files changed is replied on and resolved fr
     [AGENT.id, { action: PULL_REQUEST_ACTION.RESOLVE_THREAD, threadId: "PRRT_flag" }],
   ]);
 });
+
+/** Writes in the comment box at the Conversation's foot as the member would. */
+function writeComment(tab: HTMLElement, words: string): HTMLTextAreaElement {
+  const field =
+    tab.querySelector<HTMLTextAreaElement>(
+      '.pull-request-comment-box textarea[aria-label="Comment"]',
+    ) ?? assert.fail("the Conversation ends in a comment box");
+  act(() => {
+    const set = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, "value")?.set;
+    set?.call(field, words);
+    field.dispatchEvent(new Event("input", { bubbles: true }));
+  });
+  return field;
+}
+
+/** The comment box's Comment press. */
+function commentPress(tab: HTMLElement): HTMLButtonElement {
+  return (
+    tab.querySelector<HTMLButtonElement>(".pull-request-comment-foot button") ??
+    assert.fail("the box offers Comment")
+  );
+}
+
+test("a comment written at the Conversation's foot is asked of the service for the agent, after which the box lets its words go and the comment stands in the conversation", async () => {
+  const tab = await draw(
+    controlAnswering({
+      conversation: () =>
+        Promise.resolve({
+          pullRequest: {
+            ...CONVERSATION,
+            conversation: [
+              ...CONVERSATION.conversation,
+              ...changes.flatMap(([, request]) =>
+                request.action === PULL_REQUEST_ACTION.COMMENT
+                  ? [
+                      {
+                        kind: CONVERSATION_ENTRY.COMMENT,
+                        by: CHARLES_ON_GITHUB,
+                        html: null,
+                        body: request.body,
+                        at: 4_000,
+                        url: `${PAGE}#issuecomment-9`,
+                      },
+                    ]
+                  : [],
+              ),
+            ],
+          },
+        }),
+    }),
+  );
+  assert.equal(commentPress(tab).disabled, true, "a blank comment is not sent");
+
+  const field = writeComment(tab, "Shipping after **lunch**.");
+  act(() => {
+    field.dispatchEvent(
+      new KeyboardEvent("keydown", { key: "Enter", metaKey: true, bubbles: true }),
+    );
+  });
+  await settle();
+
+  assert.deepEqual(changes, [
+    [AGENT.id, { action: PULL_REQUEST_ACTION.COMMENT, body: "Shipping after **lunch**." }],
+  ]);
+  assert.equal(
+    tab.querySelector<HTMLTextAreaElement>(".pull-request-comment-box textarea")?.value,
+    "",
+    "the box lets its words go",
+  );
+  assert.match(
+    tab.querySelector(".pull-request-conversation")?.textContent ?? "",
+    /Shipping after lunch\./u,
+  );
+});
+
+test("a comment GitHub refuses says so under the box in GitHub's own words, its words kept for another try", async () => {
+  changeAnswer = {
+    outcome: PULL_REQUEST_WRITE_OUTCOME.REFUSED,
+    words: "Conversation is locked to collaborators",
+  };
+  const tab = await draw(controlAnswering());
+
+  writeComment(tab, "Ping?");
+  act(() => commentPress(tab).click());
+  await settle();
+
+  assert.equal(
+    tab.querySelector(".pull-request-comment-note .failure-note-words")?.textContent,
+    "GitHub said: Conversation is locked to collaborators",
+  );
+  assert.equal(
+    tab.querySelector<HTMLTextAreaElement>(".pull-request-comment-box textarea")?.value,
+    "Ping?",
+  );
+});
diff --git a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx
index c6231f978e..c963560e08 100644
--- a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx
+++ b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx
@@ -91,6 +91,7 @@ import {
 import { PierreDiff, useDiffLook } from "./file-diff";
 import { useFileViewSettings } from "./file-view-settings";
 import { blockedWords, MergeActions } from "./merge-box";
+import { PullRequestCommentBox } from "./pull-request-comment-box";
 import { PullRequestLabels } from "./pull-request-labels";
 import { HeaderReviewers, OpenedBy, PersonRef, ReviewStanding } from "./pull-request-people";
 import { Reactions } from "./pull-request-reactions";
@@ -1490,15 +1491,18 @@ function ConversationFilterRow({
   );
 }
 
-/** The Conversation tab: its filters, then the description, then the comments, reviews, and threads, in one scroll under them. */
+/** The Conversation tab: its filters, then the description, then the comments, reviews, and threads, in one scroll under them, and, once the conversation is read, the box a new comment is written in at its foot. */
 function ConversationView({
   agentId,
   parts,
   url,
+  comment,
 }: {
   agentId: string;
   parts: OverviewParts;
   url: string | undefined;
+  /** The comment box's own change, apart from the others, so it says its own answer under itself. */
+  comment: PullRequestWrites;
 }): React.JSX.Element {
   const now = useMinute();
   const picture = usePictureDrawer(agentId);
@@ -1523,6 +1527,7 @@ function ConversationView({
           now={now}
           picture={picture}
         />
+        {conversation === undefined ? null : <PullRequestCommentBox writes={comment} />}
       </div>
     </>
   );
@@ -1637,6 +1642,7 @@ export function AgentPullRequestTab({
   const writes = usePullRequestWrites(agentId, written);
   const review = usePullRequestWrites(agentId, written);
   const picture = usePictureDrawer(agentId);
+  const comment = usePullRequestWrites(agentId, written);
   // Every review thread the tab draws, in the Conversation or on its line, replies and resolves on this agent's pull request.
   return (
     <ThreadWritesProvider value={{ agentId, onWritten: written }}>
@@ -1674,7 +1680,12 @@ export function AgentPullRequestTab({
               aria-labelledby={ids(PULL_REQUEST_VIEW.CONVERSATION).tab}
               hidden={view !== PULL_REQUEST_VIEW.CONVERSATION}
             >
-              <ConversationView agentId={agentId} parts={parts} url={title?.url} />
+              <ConversationView
+                agentId={agentId}
+                parts={parts}
+                url={title?.url}
+                comment={comment}
+              />
             </div>
             <div
               className="pull-request-view"
diff --git a/apps/desktop/src/renderer/tasks/markdown-field.tsx b/apps/desktop/src/renderer/tasks/markdown-field.tsx
new file mode 100644
index 0000000000..429e9b901b
--- /dev/null
+++ b/apps/desktop/src/renderer/tasks/markdown-field.tsx
@@ -0,0 +1,89 @@
+import { PULL_REQUEST_WRITE_BOUNDS } from "@luke/features/pull-request-write-wire";
+import { TextArea } from "@luke/ui";
+import { type Ref, useState } from "react";
+import { Segmented } from "../segmented";
+import { TranscriptWords } from "./transcript-blocks";
+
+/**
+ * markdown-field.tsx -- a field for words a member sends to GitHub as Markdown, with Write and Preview as GitHub's own comment box offers them: the review panel's, and the conversation's comment box.
+ *
+ * Write is the app's own text area (`TextArea`), bounded at GitHub's length
+ * for a comment; Preview draws what is written as the transcript draws
+ * Markdown, which is near enough GitHub's own rendering to read it back
+ * before sending. The words are the owner's, so they stand whichever is
+ * shown.
+ */
+
+/** The field's own words. */
+const FIELD_WORDS = {
+  MODE: "view",
+  WRITE: "Write",
+  PREVIEW: "Preview",
+  NOTHING: "Nothing to preview.",
+} as const;
+
+/** Whether the field shows what is written or how it reads. */
+const BODY_MODE = {
+  WRITE: "write",
+  PREVIEW: "preview",
+} as const;
+
+type BodyMode = (typeof BODY_MODE)[keyof typeof BODY_MODE];
+
+/** The words, Write and Preview over them, the field named `label` to a reader. */
+export function MarkdownField({
+  label,
+  placeholder,
+  value,
+  onChange,
+  busy,
+  fieldRef,
+  onSubmit,
+}: {
+  label: string;
+  placeholder: string;
+  value: string;
+  onChange: (value: string) => void;
+  /** Whether the words are on their way to GitHub, so the field takes no typing. */
+  busy: boolean;
+  /** The field itself, for an owner that focuses it as it opens. */
+  fieldRef?: Ref<HTMLTextAreaElement>;
+  /** What ⌘↩ in the field does, where the owner does not answer it itself. */
+  onSubmit?: () => void;
+}): React.JSX.Element {
+  const [mode, setMode] = useState<BodyMode>(BODY_MODE.WRITE);
+  return (
+    <div className="markdown-field">
+      <Segmented
+        legend={`${label} ${FIELD_WORDS.MODE}`}
+        options={[
+          { value: BODY_MODE.WRITE, label: FIELD_WORDS.WRITE },
+          { value: BODY_MODE.PREVIEW, label: FIELD_WORDS.PREVIEW },
+        ]}
+        value={mode}
+        onChange={setMode}
+      />
+      {mode === BODY_MODE.WRITE ? (
+        <TextArea
+          ref={fieldRef}
+          label={label}
+          placeholder={placeholder}
+          value={value}
+          maxLength={PULL_REQUEST_WRITE_BOUNDS.MAX_BODY_CHARS}
+          rows={4}
+          busy={busy}
+          onChange={onChange}
+          onSubmit={onSubmit}
+        />
+      ) : (
+        <div className="markdown-field-preview pull-request-words">
+          {value.trim() === "" ? (
+            <p className="pull-request-quiet">{FIELD_WORDS.NOTHING}</p>
+          ) : (
+            <TranscriptWords text={value} />
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/tasks/pull-request-comment-box.tsx b/apps/desktop/src/renderer/tasks/pull-request-comment-box.tsx
new file mode 100644
index 0000000000..ae723f13a5
--- /dev/null
+++ b/apps/desktop/src/renderer/tasks/pull-request-comment-box.tsx
@@ -0,0 +1,69 @@
+import { PULL_REQUEST_ACTION } from "@luke/features/pull-request-write-wire";
+import { BUTTON_VARIANT, Button } from "@luke/ui";
+import { useState } from "react";
+import { MarkdownField } from "./markdown-field";
+import { PullRequestWriteNote, type PullRequestWrites } from "./pull-request-writes";
+
+/**
+ * pull-request-comment-box.tsx -- the comment box at the foot of an agent's pull request's Conversation, as GitHub's own: a new comment on the pull request itself, in Markdown.
+ *
+ * The comment is one change (`PULL_REQUEST_ACTION.COMMENT`), made on GitHub
+ * by the service as the member pressing Comment, on their own GitHub
+ * sign-in and never the Luke GitHub App's. Once GitHub took it the box lets
+ * its words go and the tab reads the conversation again, so the comment
+ * stands in it; GitHub's refusal stands under the box in its own words,
+ * with the sign-in offered where GitHub would not take the member's, and
+ * the words written stay for another try.
+ */
+
+/** The box's own words. */
+const COMMENT_WORDS = {
+  TITLE: "Add a comment",
+  FIELD: "Comment",
+  PLACEHOLDER: "Leave a comment in Markdown…",
+  SEND: "Comment",
+  SENDING: "Commenting",
+} as const;
+
+/** The box: its heading, the words with their preview, GitHub's answer where it did not take the last one, and Comment, which ⌘↩ presses too. */
+export function PullRequestCommentBox({
+  writes,
+}: {
+  writes: PullRequestWrites;
+}): React.JSX.Element {
+  const [body, setBody] = useState("");
+  const sending = writes.pending !== undefined;
+  const blank = body.trim() === "";
+  const send = () => {
+    if (blank || sending) return;
+    writes.write({ action: PULL_REQUEST_ACTION.COMMENT, body }, () => setBody(""));
+  };
+  return (
+    <section
+      className="pull-request-section pull-request-comment-box"
+      aria-label={COMMENT_WORDS.TITLE}
+    >
+      <h3 className="pull-request-heading">{COMMENT_WORDS.TITLE}</h3>
+      <MarkdownField
+        label={COMMENT_WORDS.FIELD}
+        placeholder={COMMENT_WORDS.PLACEHOLDER}
+        value={body}
+        onChange={setBody}
+        busy={sending}
+        onSubmit={send}
+      />
+      <PullRequestWriteNote writes={writes} className="pull-request-comment-note" />
+      <div className="pull-request-comment-foot">
+        <Button
+          variant={BUTTON_VARIANT.PRIMARY}
+          disabled={blank}
+          busy={sending}
+          busyLabel={COMMENT_WORDS.SENDING}
+          onClick={send}
+        >
+          {COMMENT_WORDS.SEND}
+        </Button>
+      </div>
+    </section>
+  );
+}
diff --git a/apps/desktop/src/renderer/tasks/pull-request-review.tsx b/apps/desktop/src/renderer/tasks/pull-request-review.tsx
index 4a5144f867..e33266d6af 100644
--- a/apps/desktop/src/renderer/tasks/pull-request-review.tsx
+++ b/apps/desktop/src/renderer/tasks/pull-request-review.tsx
@@ -1,6 +1,5 @@
 import {
   PULL_REQUEST_ACTION,
-  PULL_REQUEST_WRITE_BOUNDS,
   REVIEW_EVENT,
   type ReviewEvent,
 } from "@luke/features/pull-request-write-wire";
@@ -11,21 +10,19 @@ import {
   ChoiceList,
   type ChoiceOption,
   POPOVER_ALIGN,
-  TextArea,
 } from "@luke/ui";
 import { MessageSquarePlusIcon } from "lucide-react";
 import { useEffect, useId, useRef, useState } from "react";
 import { PopoverPanel } from "../popover-panel";
-import { Segmented } from "../segmented";
+import { MarkdownField } from "./markdown-field";
 import { PullRequestWriteNote, type PullRequestWrites } from "./pull-request-writes";
-import { TranscriptWords } from "./transcript-blocks";
 
 /**
  * pull-request-review.tsx -- the review a member submits on an agent's pull request from its Pull request tab: the bar's Review press and the panel it opens, as stage-cli's review panel.
  *
  * The panel asks what the review says of the pull request, Comment,
  * Approve, or Request changes, and its optional words, written as
- * Markdown with a preview, and sends both as one change
+ * Markdown with a preview (`markdown-field.tsx`), and sends both as one change
  * (`PULL_REQUEST_ACTION.SUBMIT_REVIEW`), which the service submits on
  * GitHub as the member pressing it: their own pending review where they
  * hold one, else a new one (`pull-request-writes.ts`). Nothing is refused
@@ -44,10 +41,6 @@ const REVIEW_WORDS = {
   LEAD: "Submitted on GitHub as you.",
   CLOSE: "Close",
   BODY: "Review comment",
-  MODE: "Review comment view",
-  WRITE: "Write",
-  PREVIEW: "Preview",
-  NOTHING: "Nothing to preview.",
   EVENTS: "What the review says",
   CANCEL: "Cancel",
   SUBMIT: "Submit review",
@@ -76,14 +69,6 @@ function placeholderOf(event: ReviewEvent): string {
     : "Leave a summary comment (optional)…";
 }
 
-/** Whether the field shows what is written or how it reads. */
-const BODY_MODE = {
-  WRITE: "write",
-  PREVIEW: "preview",
-} as const;
-
-type BodyMode = (typeof BODY_MODE)[keyof typeof BODY_MODE];
-
 /** The width the panel asks for, stage-cli's own; the side panel may narrow it. */
 const PANEL_WIDTH = 480;
 
@@ -116,7 +101,6 @@ function ReviewPanel({
   onLeave: (left: EventTarget | null) => void;
 }): React.JSX.Element {
   const field = useRef<HTMLTextAreaElement>(null);
-  const [mode, setMode] = useState<BodyMode>(BODY_MODE.WRITE);
   const sending = writes.pending !== undefined;
 
   const onKey = (event: React.KeyboardEvent) => {
@@ -136,37 +120,14 @@ function ReviewPanel({
       onKeyDown={onKey}
     >
       <p className="pull-request-review-lead">{REVIEW_WORDS.LEAD}</p>
-      <div className="pull-request-review-body">
-        <Segmented
-          legend={REVIEW_WORDS.MODE}
-          options={[
-            { value: BODY_MODE.WRITE, label: REVIEW_WORDS.WRITE },
-            { value: BODY_MODE.PREVIEW, label: REVIEW_WORDS.PREVIEW },
-          ]}
-          value={mode}
-          onChange={setMode}
-        />
-        {mode === BODY_MODE.WRITE ? (
-          <TextArea
-            ref={field}
-            label={REVIEW_WORDS.BODY}
-            placeholder={placeholderOf(draft.event)}
-            value={draft.body}
-            maxLength={PULL_REQUEST_WRITE_BOUNDS.MAX_BODY_CHARS}
-            rows={4}
-            busy={sending}
-            onChange={draft.setBody}
-          />
-        ) : (
-          <div className="pull-request-review-preview pull-request-words">
-            {draft.body.trim() === "" ? (
-              <p className="pull-request-quiet">{REVIEW_WORDS.NOTHING}</p>
-            ) : (
-              <TranscriptWords text={draft.body} />
-            )}
-          </div>
-        )}
-      </div>
+      <MarkdownField
+        label={REVIEW_WORDS.BODY}
+        placeholder={placeholderOf(draft.event)}
+        value={draft.body}
+        onChange={draft.setBody}
+        busy={sending}
+        fieldRef={field}
+      />
       <ChoiceList<ReviewEvent>
         legend={REVIEW_WORDS.EVENTS}
         options={EVENT_OPTIONS}
diff --git a/apps/desktop/src/renderer/tasks/pull-request-writes.tsx b/apps/desktop/src/renderer/tasks/pull-request-writes.tsx
index c72677c151..2ab953f509 100644
--- a/apps/desktop/src/renderer/tasks/pull-request-writes.tsx
+++ b/apps/desktop/src/renderer/tasks/pull-request-writes.tsx
@@ -59,6 +59,7 @@ const ACTION_WORDS = {
   [PULL_REQUEST_ACTION.ENABLE_AUTO_MERGE]: "Enable auto-merge",
   [PULL_REQUEST_ACTION.DISABLE_AUTO_MERGE]: "Disable auto-merge",
   [PULL_REQUEST_ACTION.DEQUEUE]: "Remove from queue",
+  [PULL_REQUEST_ACTION.COMMENT]: "Comment",
 } as const satisfies Record<PullRequestAction, string>;
 
 /** The word for where the pull request stands, which the pill says. */
diff --git a/packages/features/fixtures/json-schema/coding-agent-view-codingAgentPullRequestActionParamsSchema.json b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentPullRequestActionParamsSchema.json
index 066854ea4d..eaa5bd8c9b 100644
--- a/packages/features/fixtures/json-schema/coding-agent-view-codingAgentPullRequestActionParamsSchema.json
+++ b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentPullRequestActionParamsSchema.json
@@ -220,6 +220,26 @@
             "threadId"
           ],
           "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "properties": {
+            "action": {
+              "type": "string",
+              "enum": [
+                "comment"
+              ]
+            },
+            "body": {
+              "type": "string",
+              "maxLength": 65536
+            }
+          },
+          "required": [
+            "action",
+            "body"
+          ],
+          "additionalProperties": false
         }
       ]
     }
diff --git a/packages/features/fixtures/json-schema/pull-request-write-wire-pullRequestActionRequestSchema.json b/packages/features/fixtures/json-schema/pull-request-write-wire-pullRequestActionRequestSchema.json
index 91279f49db..8229e37c40 100644
--- a/packages/features/fixtures/json-schema/pull-request-write-wire-pullRequestActionRequestSchema.json
+++ b/packages/features/fixtures/json-schema/pull-request-write-wire-pullRequestActionRequestSchema.json
@@ -213,6 +213,26 @@
         "threadId"
       ],
       "additionalProperties": false
+    },
+    {
+      "type": "object",
+      "properties": {
+        "action": {
+          "type": "string",
+          "enum": [
+            "comment"
+          ]
+        },
+        "body": {
+          "type": "string",
+          "maxLength": 65536
+        }
+      },
+      "required": [
+        "action",
+        "body"
+      ],
+      "additionalProperties": false
     }
   ]
 }
diff --git a/packages/features/src/pull-request-write-wire.ts b/packages/features/src/pull-request-write-wire.ts
index ffcf070b69..6385d4488a 100644
--- a/packages/features/src/pull-request-write-wire.ts
+++ b/packages/features/src/pull-request-write-wire.ts
@@ -71,6 +71,8 @@ export const PULL_REQUEST_ACTION = {
   RESOLVE_THREAD: "resolve-thread",
   /** A resolved review thread of the pull request opened again. */
   UNRESOLVE_THREAD: "unresolve-thread",
+  /** A comment on the pull request itself, at the foot of its conversation. */
+  COMMENT: "comment",
 } as const;
 
 export type PullRequestAction = (typeof PULL_REQUEST_ACTION)[keyof typeof PULL_REQUEST_ACTION];
@@ -95,7 +97,7 @@ const threadIdSchema = EffectSchema.NonEmptyString.check(
   EffectSchema.isMaxLength(PULL_REQUEST_WRITE_BOUNDS.MAX_NODE_ID_CHARS),
 );
 
-/** A reply's words, Markdown, never blank; GitHub's bound. */
+/** A reply's or a comment's words, Markdown, never blank; GitHub's bound. */
 const replyBodySchema = reviewBodySchema.check(EffectSchema.isPattern(/\S/u));
 
 /** One change, as the tab asks the service to make it (POST). */
@@ -132,6 +134,10 @@ export const pullRequestActionRequestSchema = EffectSchema.Union([
     action: EffectSchema.Literal(PULL_REQUEST_ACTION.UNRESOLVE_THREAD),
     threadId: threadIdSchema,
   }),
+  EffectSchema.Struct({
+    action: EffectSchema.Literal(PULL_REQUEST_ACTION.COMMENT),
+    body: replyBodySchema,
+  }),
 ]);
 
 export type PullRequestActionRequest = typeof pullRequestActionRequestSchema.Type;
diff --git a/packages/service/src/agents/coding-agents-app.test.ts b/packages/service/src/agents/coding-agents-app.test.ts
index 6113096555..f442a5e19c 100644
--- a/packages/service/src/agents/coding-agents-app.test.ts
+++ b/packages/service/src/agents/coding-agents-app.test.ts
@@ -1878,6 +1878,34 @@ it.layer(getTestDB())("changing an agent's pull request", (it) => {
       }),
   );
 
+  it.effect(
+    "a member comments on the pull request itself on their own token, and a blank comment never reaches GitHub",
+    () =>
+      Effect.gen(function* () {
+        const { other, agent, calls, ask } = yield* published({ otherToken: "ghu_teammate" });
+
+        const commented = yield* ask(
+          threadActionAs(other, agent.id, { action: "comment", body: "Shipping after lunch." }),
+        );
+        const blank = yield* ask(
+          threadActionAs(other, agent.id, { action: "comment", body: "\n" }),
+        );
+
+        assert.deepEqual(commented, { status: HOSTED_HTTP_STATUS.OK, body: { outcome: "done" } });
+        assert.deepEqual(
+          blank,
+          refusal(HOSTED_HTTP_STATUS.BAD_REQUEST, HOSTED_API_ERROR.INVALID_REQUEST),
+        );
+        assert.deepEqual(
+          calls
+            .filter((call) => call.query.includes("mutation"))
+            .map((call) => [mutationName(call.query), call.variables]),
+          [["addComment", { id: PULL_REQUEST_NODE_ID, body: "Shipping after lunch." }]],
+        );
+        assert.ok(calls.every((call) => call.authorization === "Bearer ghu_teammate"));
+      }),
+  );
+
   it.effect(
     "an account outside the agent's workspace is answered as if the agent were none, and a change the wire does not name is refused, neither reaching GitHub",
     () =>
diff --git a/packages/service/src/agents/coding-agents-app.ts b/packages/service/src/agents/coding-agents-app.ts
index 52e1641d5f..c31d6a1a1f 100644
--- a/packages/service/src/agents/coding-agents-app.ts
+++ b/packages/service/src/agents/coding-agents-app.ts
@@ -81,6 +81,7 @@ import {
 import { githubReadOrRefusal, logGitHubReadFailure } from "../github/github-refusal.js";
 import { pullRequestMerging } from "../github/pull-request-merging.js";
 import {
+  commentOnPullRequest,
   type GitHubWriteFailure,
   mergePullRequest,
   pullRequestNodeId,
@@ -239,8 +240,8 @@ import {
  * and where its reviewers stand (`GET /api/agents/{id}/overview/conversation`),
  * its words as GitHub renders them. A change to that pull request
  * (`POST /api/agents/{id}/pull-request/action`), such as marking it ready for
- * review, submitting a review, or replying on or resolving a review
- * thread, is made on GitHub as the member who asks, on their own GitHub
+ * review, submitting a review, replying on or resolving a review thread,
+ * or commenting on it, is made on GitHub as the member who asks, on their own GitHub
  * sign-in and never the App's, through the one seam every such change takes
  * (`pull-request-write.ts`), and answers how GitHub took it; the agent's kept
  * published answer is let go, so the next read asks GitHub afresh. An image
@@ -1117,6 +1118,8 @@ function writeOf(
         request.threadId,
         request.action === PULL_REQUEST_ACTION.RESOLVE_THREAD,
       );
+    case PULL_REQUEST_ACTION.COMMENT:
+      return commentOnPullRequest(token, id, request.body);
   }
 }
 
diff --git a/packages/service/src/github/pull-request-writes.ts b/packages/service/src/github/pull-request-writes.ts
index 79bfe65819..9f11602480 100644
--- a/packages/service/src/github/pull-request-writes.ts
+++ b/packages/service/src/github/pull-request-writes.ts
@@ -417,3 +417,18 @@ export const takeOutOfMergeQueue = /* @__PURE__ */ Effect.fn("web/takeOutOfMerge
 ): Effect.fn.Return<void, GitHubWriteFailure, HttpClient.HttpClient> {
   yield* githubWrite(token, DEQUEUE_MUTATION, { id: pullRequestId }, Schema.Unknown);
 });
+
+const COMMENT_MUTATION = `mutation($id: ID!, $body: String!) {
+  addComment(input: { subjectId: $id, body: $body }) { commentEdge { node { id } } }
+}`;
+
+/** A comment on the pull request itself, at the foot of its conversation, on the member's token. */
+export const commentOnPullRequest = /* @__PURE__ */ Effect.fn("web/commentOnPullRequest")(
+  function* (
+    token: Redacted.Redacted,
+    pullRequestId: string,
+    body: string,
+  ): Effect.fn.Return<void, GitHubWriteFailure, HttpClient.HttpClient> {
+    yield* githubWrite(token, COMMENT_MUTATION, { id: pullRequestId, body }, Schema.Unknown);
+  },
+);

From 798c4cb3a913fc149b6d67e4a17cb02cc8be63a0 Mon Sep 17 00:00:00 2001
From: Dean Stratakos <29683763+dastratakos@users.noreply.github.com>
Date: Sun, 18 Oct 2026 16:08:56 +0000
Subject: [PATCH 2/7] fix(desktop): keep a comment being written when a
 conversation read fails

The comment box is drawn only while the conversation stands read, so a
refresh that failed took it away and Retry brought back an empty one.
The tab now holds the box's words (`usePullRequestComment`), so they
stand again once the conversation is read.

Co-authored-by: luke-agent[bot] <339870089+luke-agent[bot]@users.noreply.github.com>
---
 .../tasks/agent-pull-request-tab.test.ts      | 45 +++++++++++++++++++
 .../renderer/tasks/agent-pull-request-tab.tsx | 14 +++---
 .../tasks/pull-request-comment-box.tsx        | 31 ++++++++++---
 3 files changed, 80 insertions(+), 10 deletions(-)

diff --git a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
index d099f51efe..f8f0a2c615 100644
--- a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
+++ b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
@@ -2629,3 +2629,48 @@ test("a comment GitHub refuses says so under the box in GitHub's own words, its
     "Ping?",
   );
 });
+
+test("a comment being written outlives a read of the conversation that failed, standing in the box again once Retry reads it", async () => {
+  let reads = 0;
+  const tab = await draw(
+    controlAnswering({
+      conversation: () => {
+        reads += 1;
+        return Promise.resolve(
+          reads === 2
+            ? { failure: CODING_AGENT_CALL_FAILURE.UNANSWERED }
+            : { pullRequest: CONVERSATION },
+        );
+      },
+    }),
+  );
+  writeComment(tab, "Half a thought");
+
+  const more =
+    tab.querySelector<HTMLButtonElement>('[aria-label="Pull request actions"]') ??
+    assert.fail("the bar has a ⋯");
+  act(() => more.click());
+  const refresh =
+    [...document.querySelectorAll<HTMLButtonElement>('[role="menuitem"]')].find(
+      (each) => each.textContent === "Refresh pull request",
+    ) ?? assert.fail("the ⋯ offers Refresh");
+  await act(async () => refresh.click());
+  await settle();
+  assert.equal(
+    tab.querySelector(".pull-request-comment-box"),
+    null,
+    "the failed read takes it away",
+  );
+
+  const retry =
+    [...tab.querySelectorAll<HTMLButtonElement>("button")].find(
+      (button) => button.textContent === "Retry",
+    ) ?? assert.fail("the failed conversation offers Retry");
+  await act(async () => retry.click());
+  await settle();
+
+  assert.equal(
+    tab.querySelector<HTMLTextAreaElement>(".pull-request-comment-box textarea")?.value,
+    "Half a thought",
+  );
+});
diff --git a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx
index c963560e08..7023f9e5b2 100644
--- a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx
+++ b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx
@@ -91,7 +91,11 @@ import {
 import { PierreDiff, useDiffLook } from "./file-diff";
 import { useFileViewSettings } from "./file-view-settings";
 import { blockedWords, MergeActions } from "./merge-box";
-import { PullRequestCommentBox } from "./pull-request-comment-box";
+import {
+  type PullRequestComment,
+  PullRequestCommentBox,
+  usePullRequestComment,
+} from "./pull-request-comment-box";
 import { PullRequestLabels } from "./pull-request-labels";
 import { HeaderReviewers, OpenedBy, PersonRef, ReviewStanding } from "./pull-request-people";
 import { Reactions } from "./pull-request-reactions";
@@ -1501,8 +1505,8 @@ function ConversationView({
   agentId: string;
   parts: OverviewParts;
   url: string | undefined;
-  /** The comment box's own change, apart from the others, so it says its own answer under itself. */
-  comment: PullRequestWrites;
+  /** The comment box's words and its own change, held by the tab so the box may come and go. */
+  comment: PullRequestComment;
 }): React.JSX.Element {
   const now = useMinute();
   const picture = usePictureDrawer(agentId);
@@ -1527,7 +1531,7 @@ function ConversationView({
           now={now}
           picture={picture}
         />
-        {conversation === undefined ? null : <PullRequestCommentBox writes={comment} />}
+        {conversation === undefined ? null : <PullRequestCommentBox comment={comment} />}
       </div>
     </>
   );
@@ -1642,7 +1646,7 @@ export function AgentPullRequestTab({
   const writes = usePullRequestWrites(agentId, written);
   const review = usePullRequestWrites(agentId, written);
   const picture = usePictureDrawer(agentId);
-  const comment = usePullRequestWrites(agentId, written);
+  const comment = usePullRequestComment(agentId, written);
   // Every review thread the tab draws, in the Conversation or on its line, replies and resolves on this agent's pull request.
   return (
     <ThreadWritesProvider value={{ agentId, onWritten: written }}>
diff --git a/apps/desktop/src/renderer/tasks/pull-request-comment-box.tsx b/apps/desktop/src/renderer/tasks/pull-request-comment-box.tsx
index ae723f13a5..e7c01c4e2e 100644
--- a/apps/desktop/src/renderer/tasks/pull-request-comment-box.tsx
+++ b/apps/desktop/src/renderer/tasks/pull-request-comment-box.tsx
@@ -2,7 +2,11 @@ import { PULL_REQUEST_ACTION } from "@luke/features/pull-request-write-wire";
 import { BUTTON_VARIANT, Button } from "@luke/ui";
 import { useState } from "react";
 import { MarkdownField } from "./markdown-field";
-import { PullRequestWriteNote, type PullRequestWrites } from "./pull-request-writes";
+import {
+  PullRequestWriteNote,
+  type PullRequestWrites,
+  usePullRequestWrites,
+} from "./pull-request-writes";
 
 /**
  * pull-request-comment-box.tsx -- the comment box at the foot of an agent's pull request's Conversation, as GitHub's own: a new comment on the pull request itself, in Markdown.
@@ -13,7 +17,10 @@ import { PullRequestWriteNote, type PullRequestWrites } from "./pull-request-wri
  * its words go and the tab reads the conversation again, so the comment
  * stands in it; GitHub's refusal stands under the box in its own words,
  * with the sign-in offered where GitHub would not take the member's, and
- * the words written stay for another try.
+ * the words written stay for another try. The words are held by the tab
+ * (`usePullRequestComment`) rather than the box, so a read of the
+ * conversation that fails, which takes the box away until Retry, loses
+ * nothing written.
  */
 
 /** The box's own words. */
@@ -25,13 +32,27 @@ const COMMENT_WORDS = {
   SENDING: "Commenting",
 } as const;
 
+/** The comment being written, held for as long as the tab stands, and its own change. */
+export interface PullRequestComment {
+  readonly writes: PullRequestWrites;
+  readonly body: string;
+  readonly setBody: (body: string) => void;
+}
+
+/** The comment box's words and change, for the tab to hold across the box coming and going. */
+export function usePullRequestComment(agentId: string, onWritten: () => void): PullRequestComment {
+  const writes = usePullRequestWrites(agentId, onWritten);
+  const [body, setBody] = useState("");
+  return { writes, body, setBody };
+}
+
 /** The box: its heading, the words with their preview, GitHub's answer where it did not take the last one, and Comment, which ⌘↩ presses too. */
 export function PullRequestCommentBox({
-  writes,
+  comment,
 }: {
-  writes: PullRequestWrites;
+  comment: PullRequestComment;
 }): React.JSX.Element {
-  const [body, setBody] = useState("");
+  const { writes, body, setBody } = comment;
   const sending = writes.pending !== undefined;
   const blank = body.trim() === "";
   const send = () => {

From 4bebc35f73a9a0d0c1d8ea020192ec9bae4cd6c3 Mon Sep 17 00:00:00 2001
From: Dean Stratakos <29683763+dastratakos@users.noreply.github.com>
Date: Sun, 18 Oct 2026 16:35:59 +0000
Subject: [PATCH 3/7] fix(desktop): draw the comment box with the Luke roles
 rather than the retired aliases

#3524 retired `--space-*` and `--text-*`, so the comment box's gap and
its refusal's colour fell back to nothing on main. They now read
`--luke-space-8`, `--luke-color-text-muted`, and
`--luke-type-caption-size`, as the thread's own note does.

Co-authored-by: luke-agent[bot] <339870089+luke-agent[bot]@users.noreply.github.com>
---
 apps/desktop/src/renderer/styles/tasks.css | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/apps/desktop/src/renderer/styles/tasks.css b/apps/desktop/src/renderer/styles/tasks.css
index 37d45383cd..85c784d7be 100644
--- a/apps/desktop/src/renderer/styles/tasks.css
+++ b/apps/desktop/src/renderer/styles/tasks.css
@@ -2555,13 +2555,13 @@ button.pull-request-check:hover {
 .pull-request-comment-box {
   display: flex;
   flex-direction: column;
-  gap: var(--space-8);
+  gap: var(--luke-space-8);
 }
 
 .pull-request-comment-note {
   margin: 0;
-  color: var(--text-secondary);
-  font-size: 12px;
+  color: var(--luke-color-text-muted);
+  font-size: var(--luke-type-caption-size);
 }
 
 .pull-request-comment-note .failure-note-words {

From de052fddb2f4a37dbd1acb0ca111e566c0eb2429 Mon Sep 17 00:00:00 2001
From: Dean Stratakos <29683763+dastratakos@users.noreply.github.com>
Date: Sun, 18 Oct 2026 17:37:20 +0000
Subject: [PATCH 4/7] feat(service,features): comment on lines and discard a
 pending review as the member, and read their pending review beside the
 conversation

Two actions join the member-writes union. `add-review-comment` comments
on lines of a changed file at the head the diff was read at: `single`
publishes it at once as a review of its own (`addPullRequestReview` with
one thread), and `review` adds it to the member's own pending review,
starting one where they hold none, which is the review the Review panel
submits. `discard-review` deletes the member's own pending review, found
by the pull request and `viewerDidAuthor`, and is refused in words where
they hold none.

The conversation's read carries the member's pending review beside it,
read in parallel on their own token (`memberReadToken`, as the reactions
read does) and never on the App's, null where they hold none, have no
sign-in, or GitHub would not answer. The changes answer names the head
its files were read at (`headSha`), read from the pull request beside
them, as #3638 names it.

Co-authored-by: luke-agent[bot] <339870089+luke-agent[bot]@users.noreply.github.com>
---
 ...ew-codingAgentChangesAnswerViewSchema.json |   3 +
 ...tOverviewConversationAnswerViewSchema.json |  20 ++
 ...ingAgentPullRequestActionParamsSchema.json |  78 ++++++
 ...t-wire-codingAgentChangesAnswerSchema.json |   3 +
 ...AgentOverviewConversationAnswerSchema.json |  20 ++
 ...e-wire-pullRequestActionRequestSchema.json |  78 ++++++
 packages/features/src/coding-agent-wire.ts    |  20 +-
 .../features/src/pull-request-write-wire.ts   |  46 ++++
 .../src/agents/coding-agents-app.test.ts      | 249 ++++++++++++++++++
 .../service/src/agents/coding-agents-app.ts   |  55 +++-
 .../service/src/agents/pull-request-write.ts  |  10 +
 .../service/src/github/pull-request-writes.ts | 135 +++++++++-
 packages/service/src/github/pull-requests.ts  |  80 ++++++
 13 files changed, 780 insertions(+), 17 deletions(-)

diff --git a/packages/features/fixtures/json-schema/coding-agent-view-codingAgentChangesAnswerViewSchema.json b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentChangesAnswerViewSchema.json
index 3e1ab6ddc3..9838a2dd1f 100644
--- a/packages/features/fixtures/json-schema/coding-agent-view-codingAgentChangesAnswerViewSchema.json
+++ b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentChangesAnswerViewSchema.json
@@ -11,6 +11,9 @@
                 "url": {
                   "type": "string"
                 },
+                "headSha": {
+                  "type": "string"
+                },
                 "files": {
                   "type": "array",
                   "items": {
diff --git a/packages/features/fixtures/json-schema/coding-agent-view-codingAgentOverviewConversationAnswerViewSchema.json b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentOverviewConversationAnswerViewSchema.json
index e07c8e4956..ddcf1a91cc 100644
--- a/packages/features/fixtures/json-schema/coding-agent-view-codingAgentOverviewConversationAnswerViewSchema.json
+++ b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentOverviewConversationAnswerViewSchema.json
@@ -472,6 +472,26 @@
                     "additionalProperties": false
                   },
                   "maxItems": 8
+                },
+                "pendingReview": {
+                  "anyOf": [
+                    {
+                      "type": "object",
+                      "properties": {
+                        "comments": {
+                          "type": "number",
+                          "minimum": 0
+                        }
+                      },
+                      "required": [
+                        "comments"
+                      ],
+                      "additionalProperties": false
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
                 }
               },
               "required": [
diff --git a/packages/features/fixtures/json-schema/coding-agent-view-codingAgentPullRequestActionParamsSchema.json b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentPullRequestActionParamsSchema.json
index eaa5bd8c9b..5cb6d2e69f 100644
--- a/packages/features/fixtures/json-schema/coding-agent-view-codingAgentPullRequestActionParamsSchema.json
+++ b/packages/features/fixtures/json-schema/coding-agent-view-codingAgentPullRequestActionParamsSchema.json
@@ -240,6 +240,84 @@
             "body"
           ],
           "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "properties": {
+            "action": {
+              "type": "string",
+              "enum": [
+                "add-review-comment"
+              ]
+            },
+            "mode": {
+              "type": "string",
+              "enum": [
+                "single",
+                "review"
+              ]
+            },
+            "path": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 4096
+            },
+            "line": {
+              "type": "integer",
+              "minimum": 1
+            },
+            "side": {
+              "type": "string",
+              "enum": [
+                "left",
+                "right"
+              ]
+            },
+            "startLine": {
+              "type": "integer",
+              "minimum": 1
+            },
+            "startSide": {
+              "type": "string",
+              "enum": [
+                "left",
+                "right"
+              ]
+            },
+            "body": {
+              "type": "string",
+              "maxLength": 65536
+            },
+            "headSha": {
+              "type": "string",
+              "maxLength": 64
+            }
+          },
+          "required": [
+            "action",
+            "mode",
+            "path",
+            "line",
+            "side",
+            "body",
+            "headSha"
+          ],
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "properties": {
+            "action": {
+              "type": "string",
+              "enum": [
+                "discard-review"
+              ]
+            }
+          },
+          "required": [
+            "action"
+          ],
+          "additionalProperties": false
         }
       ]
     }
diff --git a/packages/features/fixtures/json-schema/coding-agent-wire-codingAgentChangesAnswerSchema.json b/packages/features/fixtures/json-schema/coding-agent-wire-codingAgentChangesAnswerSchema.json
index ef853d7311..b54957825e 100644
--- a/packages/features/fixtures/json-schema/coding-agent-wire-codingAgentChangesAnswerSchema.json
+++ b/packages/features/fixtures/json-schema/coding-agent-wire-codingAgentChangesAnswerSchema.json
@@ -9,6 +9,9 @@
             "url": {
               "type": "string"
             },
+            "headSha": {
+              "type": "string"
+            },
             "files": {
               "type": "array",
               "items": {
diff --git a/packages/features/fixtures/json-schema/coding-agent-wire-codingAgentOverviewConversationAnswerSchema.json b/packages/features/fixtures/json-schema/coding-agent-wire-codingAgentOverviewConversationAnswerSchema.json
index d117e8f659..9f6cfd10a1 100644
--- a/packages/features/fixtures/json-schema/coding-agent-wire-codingAgentOverviewConversationAnswerSchema.json
+++ b/packages/features/fixtures/json-schema/coding-agent-wire-codingAgentOverviewConversationAnswerSchema.json
@@ -470,6 +470,26 @@
                 "additionalProperties": false
               },
               "maxItems": 8
+            },
+            "pendingReview": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "properties": {
+                    "comments": {
+                      "type": "number",
+                      "minimum": 0
+                    }
+                  },
+                  "required": [
+                    "comments"
+                  ],
+                  "additionalProperties": false
+                },
+                {
+                  "type": "null"
+                }
+              ]
             }
           },
           "required": [
diff --git a/packages/features/fixtures/json-schema/pull-request-write-wire-pullRequestActionRequestSchema.json b/packages/features/fixtures/json-schema/pull-request-write-wire-pullRequestActionRequestSchema.json
index 8229e37c40..9af4ef73e2 100644
--- a/packages/features/fixtures/json-schema/pull-request-write-wire-pullRequestActionRequestSchema.json
+++ b/packages/features/fixtures/json-schema/pull-request-write-wire-pullRequestActionRequestSchema.json
@@ -233,6 +233,84 @@
         "body"
       ],
       "additionalProperties": false
+    },
+    {
+      "type": "object",
+      "properties": {
+        "action": {
+          "type": "string",
+          "enum": [
+            "add-review-comment"
+          ]
+        },
+        "mode": {
+          "type": "string",
+          "enum": [
+            "single",
+            "review"
+          ]
+        },
+        "path": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 4096
+        },
+        "line": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "side": {
+          "type": "string",
+          "enum": [
+            "left",
+            "right"
+          ]
+        },
+        "startLine": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "startSide": {
+          "type": "string",
+          "enum": [
+            "left",
+            "right"
+          ]
+        },
+        "body": {
+          "type": "string",
+          "maxLength": 65536
+        },
+        "headSha": {
+          "type": "string",
+          "maxLength": 64
+        }
+      },
+      "required": [
+        "action",
+        "mode",
+        "path",
+        "line",
+        "side",
+        "body",
+        "headSha"
+      ],
+      "additionalProperties": false
+    },
+    {
+      "type": "object",
+      "properties": {
+        "action": {
+          "type": "string",
+          "enum": [
+            "discard-review"
+          ]
+        }
+      },
+      "required": [
+        "action"
+      ],
+      "additionalProperties": false
     }
   ]
 }
diff --git a/packages/features/src/coding-agent-wire.ts b/packages/features/src/coding-agent-wire.ts
index 06cb71d7de..c318cbb288 100644
--- a/packages/features/src/coding-agent-wire.ts
+++ b/packages/features/src/coding-agent-wire.ts
@@ -885,6 +885,9 @@ const reviewCommentSchema = EffectSchema.Struct({
   at: countedNumber,
 });
 
+/** A commit as GitHub names it: forty hex digits. */
+const commitShaSchema = EffectSchema.String.check(EffectSchema.isPattern(/^[0-9a-f]{40}$/u));
+
 /**
  * One agent's changes (GET): the pull request it published, as its page on
  * GitHub, its files in the order GitHub lists them now, and whether the
@@ -894,12 +897,15 @@ const reviewCommentSchema = EffectSchema.Struct({
  * reviewers and where each stands, who authored its commits, and its
  * reviews that said something ride beside the files, each absent from a
  * service before them, and who the agent writes as absent too for an agent
- * whose first session never settled it.
+ * whose first session never settled it. The head its files were read at
+ * rides beside them too (`headSha`), which a comment on one of their lines
+ * is anchored to, absent where it could not be read.
  */
 export const codingAgentChangesAnswerSchema = EffectSchema.Struct({
   pullRequest: EffectSchema.NullOr(
     EffectSchema.Struct({
       url: EffectSchema.String,
+      headSha: EffectSchema.optionalKey(commitShaSchema),
       files: EffectSchema.Array(changedFileSchema).check(
         EffectSchema.isMaxLength(CHANGES_BOUNDS.MAX_FILES),
       ),
@@ -1311,10 +1317,13 @@ export type CodingAgentOverviewChecks = NonNullable<
  * read's reviewers still asked for override; and its comments and reviews,
  * oldest first, its newest entries kept up to the bound, with how many
  * earlier ones were left on GitHub (`earlier`), review threads past their
- * bound among them; and the reactions its description wears, read with the
+ * bound among them; the reactions its description wears, read with the
  * conversation rather than the description itself, since they are read in
- * the same ask as the reactions of its comments. Null where the agent has
- * opened no pull request yet.
+ * the same ask as the reactions of its comments; and, read beside it on the
+ * reader's own token, the review they hold pending on it, by how many
+ * comments it holds, null where they hold none or it could not be read as
+ * theirs, absent from a service before it. Null where the agent has opened
+ * no pull request yet.
  */
 export const codingAgentOverviewConversationAnswerSchema = EffectSchema.Struct({
   pullRequest: EffectSchema.NullOr(
@@ -1327,6 +1336,9 @@ export const codingAgentOverviewConversationAnswerSchema = EffectSchema.Struct({
       ),
       earlier: countedNumber,
       descriptionReactions: EffectSchema.optionalKey(reactionsSchema),
+      pendingReview: EffectSchema.optionalKey(
+        EffectSchema.NullOr(EffectSchema.Struct({ comments: countedNumber })),
+      ),
     }),
   ),
 });
diff --git a/packages/features/src/pull-request-write-wire.ts b/packages/features/src/pull-request-write-wire.ts
index 6385d4488a..027f3227f9 100644
--- a/packages/features/src/pull-request-write-wire.ts
+++ b/packages/features/src/pull-request-write-wire.ts
@@ -26,6 +26,8 @@ export const PULL_REQUEST_WRITE_BOUNDS = {
   MAX_BODY_CHARS: 65_536,
   /** The longest GitHub id for a review thread the request names; GitHub's run near thirty. */
   MAX_NODE_ID_CHARS: 256,
+  /** The longest path a line comment names; GitHub's own paths stop well short of it. */
+  MAX_PATH_CHARS: 4_096,
 } as const;
 
 /** How a pull request is merged, as GitHub offers each where the repository allows it. */
@@ -73,6 +75,10 @@ export const PULL_REQUEST_ACTION = {
   UNRESOLVE_THREAD: "unresolve-thread",
   /** A comment on the pull request itself, at the foot of its conversation. */
   COMMENT: "comment",
+  /** A comment on a line or lines of a changed file, published at once or added to the member's pending review. */
+  ADD_REVIEW_COMMENT: "add-review-comment",
+  /** The member's own pending review thrown away, the comments it held with it. */
+  DISCARD_REVIEW: "discard-review",
 } as const;
 
 export type PullRequestAction = (typeof PULL_REQUEST_ACTION)[keyof typeof PULL_REQUEST_ACTION];
@@ -87,6 +93,27 @@ export const REVIEW_EVENT = {
 
 export type ReviewEvent = (typeof REVIEW_EVENT)[keyof typeof REVIEW_EVENT];
 
+/** Where a line comment goes, as GitHub's own line comment offers: published at once as a review of its own, or added to the member's pending review, which one is started for where they hold none. */
+export const REVIEW_COMMENT_MODE = {
+  SINGLE: "single",
+  REVIEW: "review",
+} as const;
+
+export type ReviewCommentMode = (typeof REVIEW_COMMENT_MODE)[keyof typeof REVIEW_COMMENT_MODE];
+
+/** The side of a diff a line comment counts its line on: the old file's, or the new file's. */
+export const REVIEW_COMMENT_SIDE = {
+  LEFT: "left",
+  RIGHT: "right",
+} as const;
+
+export type ReviewCommentSide = (typeof REVIEW_COMMENT_SIDE)[keyof typeof REVIEW_COMMENT_SIDE];
+
+const reviewCommentSideSchema = EffectSchema.Literals(Object.values(REVIEW_COMMENT_SIDE));
+
+/** A line of a file, counted from one. */
+const fileLineSchema = EffectSchema.Int.check(EffectSchema.isGreaterThanOrEqualTo(1));
+
 /** A review's words, Markdown, which may be empty where GitHub allows it; GitHub's bound. */
 const reviewBodySchema = EffectSchema.String.check(
   EffectSchema.isMaxLength(PULL_REQUEST_WRITE_BOUNDS.MAX_BODY_CHARS),
@@ -138,6 +165,25 @@ export const pullRequestActionRequestSchema = EffectSchema.Union([
     action: EffectSchema.Literal(PULL_REQUEST_ACTION.COMMENT),
     body: replyBodySchema,
   }),
+  /**
+   * A comment on the lines from `startLine` on `startSide` to `line` on
+   * `side` of the file at `path`, as the diff read at `headSha` counts them;
+   * one line where no start is named.
+   */
+  EffectSchema.Struct({
+    action: EffectSchema.Literal(PULL_REQUEST_ACTION.ADD_REVIEW_COMMENT),
+    mode: EffectSchema.Literals(Object.values(REVIEW_COMMENT_MODE)),
+    path: EffectSchema.NonEmptyString.check(
+      EffectSchema.isMaxLength(PULL_REQUEST_WRITE_BOUNDS.MAX_PATH_CHARS),
+    ),
+    line: fileLineSchema,
+    side: reviewCommentSideSchema,
+    startLine: EffectSchema.optionalKey(fileLineSchema),
+    startSide: EffectSchema.optionalKey(reviewCommentSideSchema),
+    body: replyBodySchema,
+    headSha: headShaSchema,
+  }),
+  EffectSchema.Struct({ action: EffectSchema.Literal(PULL_REQUEST_ACTION.DISCARD_REVIEW) }),
 ]);
 
 export type PullRequestActionRequest = typeof pullRequestActionRequestSchema.Type;
diff --git a/packages/service/src/agents/coding-agents-app.test.ts b/packages/service/src/agents/coding-agents-app.test.ts
index f442a5e19c..90da706742 100644
--- a/packages/service/src/agents/coding-agents-app.test.ts
+++ b/packages/service/src/agents/coding-agents-app.test.ts
@@ -111,8 +111,10 @@ import {
   CODING_AGENT_STATUS,
   type CodingAgentMessage,
   codingAgentAnswerSchema,
+  codingAgentChangesAnswerSchema,
   codingAgentListAnswerSchema,
   codingAgentMessagesAnswerSchema,
+  codingAgentOverviewConversationAnswerSchema,
   codingAgentOverviewPullRequestAnswerSchema,
   codingAgentPageAnswerSchema,
   codingAgentPullRequestAnswerSchema,
@@ -1284,6 +1286,8 @@ it.layer(getTestDB())("the coding-agent routes", (it) => {
 
 const AGENT_PULL_REQUEST_ACTION = "/api/agents/pull-request-action";
 const AGENT_PULL_REQUEST = "/api/agents/pull-request";
+/** The agent's changes, the files Files changed draws. */
+const AGENT_CHANGES = "/api/agents/changes";
 const AGENT_OVERVIEW_PULL_REQUEST = AGENT_OVERVIEW[0];
 
 /** The GraphQL id GitHub gives the published pull request. */
@@ -1422,6 +1426,46 @@ function mutationName(query: string): string {
   return /\{\s*(\w+)\(/u.exec(query)?.[1] ?? "";
 }
 
+/** The head a line comment names, as GitHub spells a commit. */
+const LINE_HEAD = "c0ffee1c0ffee1c0ffee1c0ffee1c0ffee1c0ffe";
+
+/** A comment on lines of the agent's pull request as the bearer given, on `src/invite.ts` line 12 on the new side unless the fields say otherwise. */
+function lineCommentAs(
+  bearer: string,
+  agentId: string,
+  fields: Readonly<Record<string, string | number>>,
+): Request {
+  return request(AGENT_PULL_REQUEST_ACTION, bearer, {
+    method: "POST",
+    id: agentId,
+    body: {
+      action: "add-review-comment",
+      path: "src/invite.ts",
+      line: 12,
+      side: "right",
+      body: "Rename this.",
+      headSha: LINE_HEAD,
+      ...fields,
+    },
+  });
+}
+
+/** GitHub answering a line comment's and a discard's calls: the member's pending reviews as given, a started review as `PRR_started`, and an empty answer to every other mutation. */
+function linesAnswering(
+  pending: readonly { readonly id: string; readonly viewerDidAuthor: boolean }[],
+): (call: GraphqlCall) => Response {
+  return (call) => {
+    if (
+      call.query.includes("addPullRequestReview(input: { pullRequestId: $id, commitOID: $commit })")
+    ) {
+      return Response.json({
+        data: { addPullRequestReview: { pullRequestReview: { id: "PRR_started" } } },
+      });
+    }
+    return reviewsAnswering(pending)(call);
+  };
+}
+
 it.layer(getTestDB())("changing an agent's pull request", (it) => {
   /** The owner's plan with an agent that published a pull request, and the other account where the test makes it a member. */
   const published = (options: {
@@ -1906,6 +1950,211 @@ it.layer(getTestDB())("changing an agent's pull request", (it) => {
       }),
   );
 
+  it.effect(
+    "a single line comment is published at once as a review of its own, on the member's token, at the head their diff was read at",
+    () =>
+      Effect.gen(function* () {
+        const { other, agent, calls, ask } = yield* published({
+          otherToken: "ghu_teammate",
+          answer: linesAnswering([]),
+        });
+
+        const answered = yield* ask(
+          lineCommentAs(other, agent.id, { mode: "single", startLine: 10, startSide: "right" }),
+        );
+
+        assert.deepEqual(answered, { status: HOSTED_HTTP_STATUS.OK, body: { outcome: "done" } });
+        const mutations = calls.filter((call) => call.query.includes("mutation"));
+        assert.deepEqual(
+          mutations.map((call) => [mutationName(call.query), call.variables]),
+          [
+            [
+              "addPullRequestReview",
+              {
+                id: PULL_REQUEST_NODE_ID,
+                commit: LINE_HEAD,
+                path: "src/invite.ts",
+                body: "Rename this.",
+                line: 12,
+                side: "RIGHT",
+                startLine: 10,
+                startSide: "RIGHT",
+              },
+            ],
+          ],
+        );
+        assert.match(mutations[0]?.query ?? "", /event: COMMENT, threads: \[/u);
+        assert.ok(calls.every((call) => call.authorization === "Bearer ghu_teammate"));
+      }),
+  );
+
+  it.effect(
+    "a comment for a review starts the member's pending review on the head their diff was read at where they hold none, and joins the one they hold otherwise, nobody else's",
+    () =>
+      Effect.gen(function* () {
+        const fresh = yield* published({ answer: linesAnswering([]) });
+        const started = yield* fresh.ask(
+          lineCommentAs(fresh.other, fresh.agent.id, { mode: "review", side: "left" }),
+        );
+        const holding = yield* published({
+          answer: linesAnswering([
+            { id: "PRR_someone_else", viewerDidAuthor: false },
+            { id: "PRR_member_pending", viewerDidAuthor: true },
+          ]),
+        });
+        const joined = yield* holding.ask(
+          lineCommentAs(holding.other, holding.agent.id, { mode: "review" }),
+        );
+
+        for (const answered of [started, joined]) {
+          assert.deepEqual(answered, { status: HOSTED_HTTP_STATUS.OK, body: { outcome: "done" } });
+        }
+        const thread = (calls: readonly GraphqlCall[]) =>
+          calls
+            .filter((call) => call.query.includes("mutation"))
+            .map((call) => [mutationName(call.query), call.variables.id ?? call.variables.review]);
+        assert.deepEqual(thread(fresh.calls), [
+          ["addPullRequestReview", PULL_REQUEST_NODE_ID],
+          ["addPullRequestReviewThread", "PRR_started"],
+        ]);
+        assert.equal(
+          fresh.calls.find((call) => call.query.includes("addPullRequestReviewThread"))?.variables
+            .side,
+          "LEFT",
+        );
+        assert.deepEqual(thread(holding.calls), [
+          ["addPullRequestReviewThread", "PRR_member_pending"],
+        ]);
+      }),
+  );
+
+  it.effect(
+    "Discard throws away the member's own pending review and nobody else's, and is refused in words where they hold none",
+    () =>
+      Effect.gen(function* () {
+        const holding = yield* published({
+          answer: linesAnswering([
+            { id: "PRR_someone_else", viewerDidAuthor: false },
+            { id: "PRR_member_pending", viewerDidAuthor: true },
+          ]),
+        });
+        const empty = yield* published({
+          answer: linesAnswering([{ id: "PRR_someone_else", viewerDidAuthor: false }]),
+        });
+
+        const discarded = yield* holding.ask(
+          actionAs(holding.other, holding.agent.id, "discard-review"),
+        );
+        const refused = yield* empty.ask(actionAs(empty.other, empty.agent.id, "discard-review"));
+
+        assert.deepEqual(discarded, { status: HOSTED_HTTP_STATUS.OK, body: { outcome: "done" } });
+        assert.deepEqual(
+          holding.calls
+            .filter((call) => call.query.includes("mutation"))
+            .map((call) => [mutationName(call.query), call.variables]),
+          [["deletePullRequestReview", { id: "PRR_member_pending" }]],
+        );
+        assert.deepEqual(refused, {
+          status: HOSTED_HTTP_STATUS.OK,
+          body: { outcome: "refused", words: "You have no pending review on this pull request." },
+        });
+        assert.ok(empty.calls.every((call) => !call.query.includes("mutation")));
+      }),
+  );
+
+  it.effect(
+    "a line comment on no line, on a side GitHub does not name, or at a head that is no commit, never reaches GitHub",
+    () =>
+      Effect.gen(function* () {
+        const { owner, agent, calls, ask } = yield* published({ answer: linesAnswering([]) });
+
+        const answers = [
+          yield* ask(lineCommentAs(owner, agent.id, { mode: "single", line: 0 })),
+          yield* ask(lineCommentAs(owner, agent.id, { mode: "single", side: "middle" })),
+          yield* ask(lineCommentAs(owner, agent.id, { mode: "review", headSha: "main" })),
+          yield* ask(lineCommentAs(owner, agent.id, { mode: "later" })),
+        ];
+
+        for (const answered of answers) {
+          assert.deepEqual(
+            answered,
+            refusal(HOSTED_HTTP_STATUS.BAD_REQUEST, HOSTED_API_ERROR.INVALID_REQUEST),
+          );
+        }
+        assert.deepEqual(calls, []);
+      }),
+  );
+
+  it.effect(
+    "each member reads the review they hold pending beside the conversation, on their own token, and one with no sign-in or whom GitHub would not answer reads none",
+    () =>
+      Effect.gen(function* () {
+        const pendingAnswer = (call: GraphqlCall) => {
+          if (!call.query.includes("ViewerPendingReview")) return Response.json({ data: null });
+          if (call.authorization === "Bearer ghu_broken") {
+            return Response.json({ message: "Server Error" }, { status: 502 });
+          }
+          const nodes =
+            call.authorization === "Bearer ghu_teammate"
+              ? [{ viewerDidAuthor: true, comments: { totalCount: 2 } }]
+              : [];
+          return Response.json({ data: { repository: { pullRequest: { reviews: { nodes } } } } });
+        };
+        const pendingOf = (
+          opened: { readonly ask: (request: Request) => Effect.Effect<Answer> },
+          bearer: string,
+          agentId: string,
+        ) =>
+          Effect.map(
+            opened.ask(request(AGENT_OVERVIEW[2], bearer, { id: agentId })),
+            (answered) =>
+              readAnswer(
+                codingAgentOverviewConversationAnswerSchema,
+                HOSTED_HTTP_STATUS.OK,
+                answered,
+              ).pullRequest?.pendingReview,
+          );
+        const two = yield* published({ otherToken: "ghu_teammate", answer: pendingAnswer });
+        const unsigned = yield* published({ otherToken: null, answer: pendingAnswer });
+        const broken = yield* published({ otherToken: "ghu_broken", answer: pendingAnswer });
+
+        assert.deepEqual(yield* pendingOf(two, two.other, two.agent.id), { comments: 2 });
+        assert.equal(yield* pendingOf(two, two.owner, two.agent.id), null);
+        assert.equal(yield* pendingOf(unsigned, unsigned.other, unsigned.agent.id), null);
+        assert.equal(yield* pendingOf(broken, broken.other, broken.agent.id), null);
+        assert.deepEqual(
+          two.calls
+            .filter((call) => call.query.includes("ViewerPendingReview"))
+            .map((call) => call.authorization),
+          ["Bearer ghu_teammate", "Bearer ghu_standing"],
+        );
+        assert.ok(unsigned.calls.every((call) => !call.query.includes("ViewerPendingReview")));
+      }),
+  );
+
+  it.effect(
+    "the changes name the head their files were read at, which a line comment is anchored to",
+    () =>
+      Effect.gen(function* () {
+        const headed: RepositoryScript = async (sent) => {
+          const answered = await publishedPullRequest(sent);
+          const pull = `/repos/${RELAY.owner}/${RELAY.name}/pulls/${PUBLISHED.number}`;
+          if (answered === undefined || new URL(sent.url).pathname !== pull) return answered;
+          const read: Record<string, unknown> = await answered.json();
+          return Response.json({ ...read, head: { ref: PUBLISHED.branch, sha: LINE_HEAD } });
+        };
+        const { owner, agent, ask } = yield* published({ repository: headed });
+
+        const changes = readAnswer(
+          codingAgentChangesAnswerSchema,
+          HOSTED_HTTP_STATUS.OK,
+          yield* ask(request(AGENT_CHANGES, owner, { id: agent.id })),
+        );
+
+        assert.equal(changes.pullRequest?.headSha, LINE_HEAD);
+      }),
+  );
+
   it.effect(
     "an account outside the agent's workspace is answered as if the agent were none, and a change the wire does not name is refused, neither reaching GitHub",
     () =>
diff --git a/packages/service/src/agents/coding-agents-app.ts b/packages/service/src/agents/coding-agents-app.ts
index c31d6a1a1f..86ebeb8dba 100644
--- a/packages/service/src/agents/coding-agents-app.ts
+++ b/packages/service/src/agents/coding-agents-app.ts
@@ -81,7 +81,9 @@ import {
 import { githubReadOrRefusal, logGitHubReadFailure } from "../github/github-refusal.js";
 import { pullRequestMerging } from "../github/pull-request-merging.js";
 import {
+  addLineComment,
   commentOnPullRequest,
+  discardPendingReview,
   type GitHubWriteFailure,
   mergePullRequest,
   pullRequestNodeId,
@@ -93,12 +95,15 @@ import {
   takeOutOfMergeQueue,
 } from "../github/pull-request-writes.js";
 import {
+  type GitHubPullRequest,
   type PullRequestReadFailure,
+  pullRequestByNumber,
   pullRequestChecks,
   pullRequestConversation,
   pullRequestDeployments,
   pullRequestFiles,
   pullRequestOverview,
+  viewerPendingReviewOf,
 } from "../github/pull-requests.js";
 import { HOSTED_HTTP_STATUS } from "../http/http.js";
 import {
@@ -168,6 +173,7 @@ import {
 import {
   type MemberPullRequest,
   memberPullRequestWrite,
+  memberReadToken,
   writeAnswerOf,
 } from "./pull-request-write.js";
 
@@ -926,14 +932,18 @@ const changesEndpoint = /* @__PURE__ */ Effect.fn("web/agentChangesEndpoint")(fu
   if (pullRequest === null) return hostedJsonResponse(HOSTED_HTTP_STATUS.OK, { pullRequest });
   const listed = yield* Effect.gen(function* () {
     const { token } = yield* agentPullRequestReach(userId, agent);
-    const [files, people] = yield* Effect.all(
+    // Note that the pull request itself is read beside its files for its head, which a comment on their lines is anchored to; a read that does not land names none.
+    const [files, people, whole] = yield* Effect.all(
       [
         pullRequestFiles(token, agent.repository, pullRequest),
         changesPeople(token, agent, pullRequest.number),
+        Effect.orElseSucceed(pullRequestByNumber(token, agent.repository, pullRequest.number), () =>
+          Option.none(),
+        ),
       ],
       { concurrency: "unbounded" },
     );
-    return { ...files, ...people };
+    return { ...headOf(whole), ...files, ...people };
   }).pipe(
     Effect.catch((failure) => {
       switch (failure._tag) {
@@ -957,11 +967,21 @@ const changesEndpoint = /* @__PURE__ */ Effect.fn("web/agentChangesEndpoint")(fu
   });
 });
 
+/** The head a pull request's files were read at, where it was read and spelled as a commit. */
+function headOf(whole: Option.Option<Pick<GitHubPullRequest, "headSha">>): { headSha?: string } {
+  return Option.match(whole, {
+    onNone: () => ({}),
+    onSome: ({ headSha }) => (/^[0-9a-f]{40}$/u.test(headSha) ? { headSha } : {}),
+  });
+}
+
 /** One of the overview's reads of the agent's pull request, on the token minted for its repository; null where GitHub holds no such pull request. */
 type OverviewRead<A> = (
   token: Redacted.Redacted,
   agent: CodingAgent,
   pullRequest: CodingAgentPullRequest,
+  /** The member reading, whose own reads mark what is theirs. */
+  userId: string,
 ) => Effect.Effect<A | null, PullRequestReadFailure, AgentsServices>;
 
 /**
@@ -985,7 +1005,7 @@ const overviewPart = /* @__PURE__ */ Effect.fnUntraced(function* <A>(
   if (pullRequest === null) return hostedJsonResponse(HOSTED_HTTP_STATUS.OK, { pullRequest });
   const part = yield* Effect.gen(function* () {
     const { token } = yield* agentPullRequestReach(userId, agent);
-    return yield* read(token, agent, pullRequest);
+    return yield* read(token, agent, pullRequest, userId);
   }).pipe(
     Effect.catch((failure) => {
       switch (failure._tag) {
@@ -1000,6 +1020,7 @@ const overviewPart = /* @__PURE__ */ Effect.fnUntraced(function* <A>(
       }
     }),
   );
+  // Note that a part may carry what is the reader's own, such as the review they hold pending, which every hosted answer's `private, no-store` keeps from anyone else.
   return hostedJsonResponse(HOSTED_HTTP_STATUS.OK, { pullRequest: part });
 });
 
@@ -1072,6 +1093,12 @@ const overviewChecksEndpoint = /* @__PURE__ */ Effect.fn("web/agentOverviewCheck
   },
 );
 
+/** The review the member holds pending on the pull request, read on their own token; none where they hold none, or no sign-in GitHub takes. */
+const memberPendingReview = (userId: string, repository: string, number: number) =>
+  Effect.flatMap(memberReadToken(userId), (token) =>
+    token === undefined ? Effect.succeed(null) : viewerPendingReviewOf(token, repository, number),
+  );
+
 /**
  * GET reads the agent's pull request's conversation: its comments, its
  * reviews and their threads, and where each reviewer stands by their
@@ -1080,9 +1107,19 @@ const overviewChecksEndpoint = /* @__PURE__ */ Effect.fn("web/agentOverviewCheck
 const overviewConversationEndpoint = /* @__PURE__ */ Effect.fn(
   "web/agentOverviewConversationEndpoint",
 )(function* (seams: CodingAgentsAppSeams, published: PublishedCache) {
-  return yield* overviewPart(seams, published, (token, agent, pullRequest) =>
-    Effect.flatMap(pullRequestConversation(token, agent.repository, pullRequest), (read) =>
-      namedOverviewConversation(agent, pullRequest.number, read),
+  return yield* overviewPart(seams, published, (token, agent, pullRequest, userId) =>
+    Effect.map(
+      Effect.all(
+        [
+          Effect.flatMap(pullRequestConversation(token, agent.repository, pullRequest), (read) =>
+            namedOverviewConversation(agent, pullRequest.number, read),
+          ),
+          memberPendingReview(userId, agent.repository, pullRequest.number),
+        ],
+        { concurrency: "unbounded" },
+      ),
+      ([conversation, pendingReview]) =>
+        conversation === null ? null : { ...conversation, pendingReview },
     ),
   );
 });
@@ -1120,6 +1157,12 @@ function writeOf(
       );
     case PULL_REQUEST_ACTION.COMMENT:
       return commentOnPullRequest(token, id, request.body);
+    case PULL_REQUEST_ACTION.ADD_REVIEW_COMMENT: {
+      const { action: _action, ...comment } = request;
+      return addLineComment(token, id, comment);
+    }
+    case PULL_REQUEST_ACTION.DISCARD_REVIEW:
+      return discardPendingReview(token, id);
   }
 }
 
diff --git a/packages/service/src/agents/pull-request-write.ts b/packages/service/src/agents/pull-request-write.ts
index 9cceec585c..9c854a0f6b 100644
--- a/packages/service/src/agents/pull-request-write.ts
+++ b/packages/service/src/agents/pull-request-write.ts
@@ -97,6 +97,16 @@ const memberToken = (userId: string) =>
     }),
   );
 
+/**
+ * The member's own token for a read that marks what is theirs, such as the
+ * reactions they gave; none where they hold no sign-in GitHub takes or it
+ * could not be read, which leaves the read unmarked rather than failing it.
+ */
+export const memberReadToken = (
+  userId: string,
+): Effect.Effect<Redacted.Redacted | undefined, never, WriteServices> =>
+  memberToken(userId).pipe(Effect.catch(() => Effect.succeed(undefined)));
+
 /** A write's failure as how it went: the token refused, GitHub's refusal, or a GitHub that did not answer. */
 function writtenOf<A>(failure: GitHubWriteFailure): Effect.Effect<MemberWritten<A>, HostedRefusal> {
   switch (failure._tag) {
diff --git a/packages/service/src/github/pull-request-writes.ts b/packages/service/src/github/pull-request-writes.ts
index 9f11602480..796f8bc165 100644
--- a/packages/service/src/github/pull-request-writes.ts
+++ b/packages/service/src/github/pull-request-writes.ts
@@ -20,7 +20,11 @@ import {
   MERGE_METHOD,
   type MergeMethod,
   PULL_REQUEST_WRITE_BOUNDS,
+  REVIEW_COMMENT_MODE,
+  REVIEW_COMMENT_SIDE,
   REVIEW_EVENT,
+  type ReviewCommentMode,
+  type ReviewCommentSide,
   type ReviewEvent,
 } from "@luke/features/pull-request-write-wire";
 import { Data, Effect, type Redacted, Schema } from "effect";
@@ -216,6 +220,13 @@ const ADD_REVIEW_MUTATION = `mutation($id: ID!, $event: PullRequestReviewEvent!,
   }
 }`;
 
+/** The member's own pending review on the pull request, by its GraphQL id; none where they hold none. GitHub shows a member only theirs, and `viewerDidAuthor` says so whatever it shows. */
+const ownPendingReview = (token: Redacted.Redacted, pullRequestId: string) =>
+  Effect.map(
+    githubWrite(token, PENDING_REVIEW_QUERY, { id: pullRequestId }, PendingReviewsSchema),
+    (pending) => pending.node.reviews.nodes.find((node) => node.viewerDidAuthor),
+  );
+
 /**
  * A review submitted on the member's token: their own pending review,
  * where they hold one, so the comments they started it with are what
@@ -230,13 +241,7 @@ export const submitPullRequestReview = /* @__PURE__ */ Effect.fn("web/submitPull
     pullRequestId: string,
     review: { readonly event: ReviewEvent; readonly body: string },
   ): Effect.fn.Return<void, GitHubWriteFailure, HttpClient.HttpClient> {
-    const pending = yield* githubWrite(
-      token,
-      PENDING_REVIEW_QUERY,
-      { id: pullRequestId },
-      PendingReviewsSchema,
-    );
-    const own = pending.node.reviews.nodes.find((node) => node.viewerDidAuthor);
+    const own = yield* ownPendingReview(token, pullRequestId);
     const event = GRAPHQL_REVIEW_EVENT[review.event];
     const body = review.body.trim() === "" ? {} : { body: review.body };
     yield* githubWrite(
@@ -432,3 +437,119 @@ export const commentOnPullRequest = /* @__PURE__ */ Effect.fn("web/commentOnPull
     yield* githubWrite(token, COMMENT_MUTATION, { id: pullRequestId, body }, Schema.Unknown);
   },
 );
+
+/** GitHub's own word for each side of a diff a line comment counts on, as `DiffSide` spells it. */
+const GRAPHQL_DIFF_SIDE = {
+  [REVIEW_COMMENT_SIDE.LEFT]: "LEFT",
+  [REVIEW_COMMENT_SIDE.RIGHT]: "RIGHT",
+} as const satisfies Record<ReviewCommentSide, string>;
+
+/** A comment on a line or lines of a changed file, as the member wrote it against the head their diff was read at. */
+export interface LineComment {
+  readonly mode: ReviewCommentMode;
+  readonly path: string;
+  readonly line: number;
+  readonly side: ReviewCommentSide;
+  readonly startLine?: number;
+  readonly startSide?: ReviewCommentSide;
+  readonly body: string;
+  readonly headSha: string;
+}
+
+/** The thread's place and words, which every line comment's document names alike. */
+const THREAD_VARIABLES =
+  "$path: String!, $body: String!, $line: Int!, $side: DiffSide!, $startLine: Int, $startSide: DiffSide";
+const THREAD_FIELDS =
+  "path: $path, body: $body, line: $line, side: $side, startLine: $startLine, startSide: $startSide";
+
+const SINGLE_COMMENT_MUTATION = `mutation($id: ID!, $commit: GitObjectID!, ${THREAD_VARIABLES}) {
+  addPullRequestReview(input: { pullRequestId: $id, commitOID: $commit, event: COMMENT, threads: [{ ${THREAD_FIELDS} }] }) {
+    pullRequestReview { id }
+  }
+}`;
+
+const START_REVIEW_MUTATION = `mutation($id: ID!, $commit: GitObjectID!) {
+  addPullRequestReview(input: { pullRequestId: $id, commitOID: $commit }) { pullRequestReview { id } }
+}`;
+
+const StartedReviewSchema = Schema.Struct({
+  addPullRequestReview: Schema.Struct({ pullRequestReview: Schema.Struct({ id: Schema.String }) }),
+});
+
+const REVIEW_THREAD_MUTATION = `mutation($review: ID!, ${THREAD_VARIABLES}) {
+  addPullRequestReviewThread(input: { pullRequestReviewId: $review, ${THREAD_FIELDS} }) { thread { id } }
+}`;
+
+/** A line comment's place and words as its document's variables: one line where no start is named. */
+function threadVariables(comment: LineComment): Readonly<Record<string, string | number>> {
+  return {
+    path: comment.path,
+    body: comment.body,
+    line: comment.line,
+    side: GRAPHQL_DIFF_SIDE[comment.side],
+    ...(comment.startLine === undefined ? undefined : { startLine: comment.startLine }),
+    ...(comment.startSide === undefined
+      ? undefined
+      : { startSide: GRAPHQL_DIFF_SIDE[comment.startSide] }),
+  };
+}
+
+/**
+ * A comment on lines of a changed file, on the member's token, as GitHub's
+ * own line comment offers it: published at once as a review of its own
+ * (`single`), as "Add single comment" does; or added to the member's own
+ * pending review (`review`), one started on the head their diff was read
+ * at where they hold none, which is the review the Review panel submits
+ * (`submitPullRequestReview`). GitHub's rules, a line outside the diff, a
+ * range across hunks, a head no longer the pull request's, are its refusal
+ * in its words.
+ */
+export const addLineComment = /* @__PURE__ */ Effect.fn("web/addLineComment")(function* (
+  token: Redacted.Redacted,
+  pullRequestId: string,
+  comment: LineComment,
+): Effect.fn.Return<void, GitHubWriteFailure, HttpClient.HttpClient> {
+  const thread = threadVariables(comment);
+  if (comment.mode === REVIEW_COMMENT_MODE.SINGLE) {
+    yield* githubWrite(
+      token,
+      SINGLE_COMMENT_MUTATION,
+      { id: pullRequestId, commit: comment.headSha, ...thread },
+      Schema.Unknown,
+    );
+    return;
+  }
+  const own = yield* ownPendingReview(token, pullRequestId);
+  const review =
+    own?.id ??
+    (yield* githubWrite(
+      token,
+      START_REVIEW_MUTATION,
+      { id: pullRequestId, commit: comment.headSha },
+      StartedReviewSchema,
+    )).addPullRequestReview.pullRequestReview.id;
+  yield* githubWrite(token, REVIEW_THREAD_MUTATION, { review, ...thread }, Schema.Unknown);
+});
+
+const DISCARD_REVIEW_MUTATION = `mutation($id: ID!) {
+  deletePullRequestReview(input: { pullRequestReviewId: $id }) { pullRequestReview { id } }
+}`;
+
+/** What the member is told where they hold no pending review on the pull request to throw away. */
+const NO_PENDING_REVIEW = "You have no pending review on this pull request.";
+
+/**
+ * The member's own pending review on the pull request thrown away, its
+ * comments with it, on their token: found by the pull request it is on and
+ * whether GitHub says they wrote it, so no other review is ever touched.
+ */
+export const discardPendingReview = /* @__PURE__ */ Effect.fn("web/discardPendingReview")(
+  function* (
+    token: Redacted.Redacted,
+    pullRequestId: string,
+  ): Effect.fn.Return<void, GitHubWriteFailure, HttpClient.HttpClient> {
+    const own = yield* ownPendingReview(token, pullRequestId);
+    if (own === undefined) return yield* refusalOf([NO_PENDING_REVIEW]);
+    yield* githubWrite(token, DISCARD_REVIEW_MUTATION, { id: own.id }, Schema.Unknown);
+  },
+);
diff --git a/packages/service/src/github/pull-requests.ts b/packages/service/src/github/pull-requests.ts
index 4dde4ff995..f2a6055b84 100644
--- a/packages/service/src/github/pull-requests.ts
+++ b/packages/service/src/github/pull-requests.ts
@@ -2118,3 +2118,83 @@ export function pullRequestDeployments(
     ),
   );
 }
+
+/** The member's own pending review on a pull request, as the conversation's read carries it: how many comments it holds. */
+export interface ViewerPendingReview {
+  readonly comments: number;
+}
+
+/** At most this many pending reviews are read to find the member's own; GitHub shows a member only theirs, so one is the most ever answered. */
+const VIEWER_PENDING_READ = 10;
+
+const VIEWER_PENDING_QUERY = `query ViewerPendingReview($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviews(states: PENDING, first: ${VIEWER_PENDING_READ}) {
+        nodes { viewerDidAuthor comments { totalCount } }
+      }
+    }
+  }
+}`;
+
+const ViewerPendingAnswerSchema = Schema.Struct({
+  data: Schema.optionalKey(
+    Schema.NullOr(
+      Schema.Struct({
+        repository: Schema.NullOr(
+          Schema.Struct({
+            pullRequest: Schema.NullOr(
+              Schema.Struct({
+                reviews: Schema.Struct({
+                  nodes: Schema.Array(
+                    Schema.NullOr(
+                      Schema.Struct({
+                        viewerDidAuthor: Schema.Boolean,
+                        comments: Schema.Struct({ totalCount: Schema.Number }),
+                      }),
+                    ),
+                  ),
+                }),
+              }),
+            ),
+          }),
+        ),
+      }),
+    ),
+  ),
+});
+
+/**
+ * The review the member holds pending on the pull request, read on their
+ * own token, since nobody else sees it; none where they hold none, and none
+ * where GitHub would not answer them, which leaves the conversation without
+ * it rather than failing it, said once in the log.
+ */
+export function viewerPendingReviewOf(
+  token: Redacted.Redacted,
+  fullName: string,
+  number: number,
+): Effect.Effect<ViewerPendingReview | null, never, HttpClient.HttpClient> {
+  const [owner = "", name = ""] = fullName.split("/");
+  const request = githubPost(GRAPHQL_PATH, token, {
+    query: VIEWER_PENDING_QUERY,
+    variables: { owner, name, number },
+  });
+  return Effect.scoped(
+    Effect.flatMap(send(request), (response) => readBody(response, ViewerPendingAnswerSchema)),
+  ).pipe(
+    Effect.map((answer) => {
+      const nodes = answer.data?.repository?.pullRequest?.reviews.nodes ?? [];
+      const own = nodes.find((node) => node?.viewerDidAuthor === true);
+      return own == null ? null : { comments: own.comments.totalCount };
+    }),
+    Effect.catch((failure) =>
+      Effect.as(
+        Effect.logWarning(
+          `the member's own pending review on pull request ${number} was not read: ${failure._tag}`,
+        ),
+        null,
+      ),
+    ),
+  );
+}

From 5420bd9ac830106ab69b1153b7f75ed7e2fd437e Mon Sep 17 00:00:00 2001
From: Dean Stratakos <29683763+dastratakos@users.noreply.github.com>
Date: Sun, 18 Oct 2026 17:53:35 +0000
Subject: [PATCH 5/7] feat(desktop): comment on lines in Files changed, and
 count and discard the pending review in Review

Files changed's list turns on Pierre's own line picking: the gutter's +
on a line, or dragged across lines, or on lines picked by their numbers,
opens a comment under the last of them, its lines lit, as GitHub's own
diff does. The comment offers Add single comment and Start a review, or
Add review comment where the member holds a pending review, and sends
`add-review-comment` at the head the files were read at. Lines GitHub
would take no comment on (a file drawn without lines of its own, a range
across hunks) open nothing (`commentLines`). GitHub's refusal stands
under the comment in its words beside Refresh changes, its words kept;
a file's words outlive the comment scrolling away.

The Review press counts the pending review's comments, its panel says
they will be published, and Discard, offered only while one is held,
asks first in the destructive tone, then sends `discard-review`. The
review panel's and the comment's fields are the shared `MarkdownField`.

Co-authored-by: luke-agent[bot] <339870089+luke-agent[bot]@users.noreply.github.com>
---
 .../src/renderer/diff-view/contract.ts        |  28 ++-
 apps/desktop/src/renderer/diff-view/index.ts  |  57 ++++-
 apps/desktop/src/renderer/styles/tasks.css    |  55 +++++
 .../src/renderer/tasks/agent-changes-tab.tsx  | 127 +++++++++-
 .../tasks/agent-pull-request-tab.test.ts      | 217 +++++++++++++++++-
 .../renderer/tasks/agent-pull-request-tab.tsx |  10 +-
 .../src/renderer/tasks/changes-model.test.ts  |  68 +++++-
 .../src/renderer/tasks/changes-model.ts       |  74 ++++++
 apps/desktop/src/renderer/tasks/diff-list.tsx |  33 ++-
 .../src/renderer/tasks/line-comment.tsx       | 158 +++++++++++++
 .../renderer/tasks/pull-request-review.tsx    |  73 +++++-
 .../renderer/tasks/pull-request-writes.tsx    |   4 +-
 .../src/agents/coding-agents-app.test.ts      |  14 +-
 .../service/src/github/pull-request-writes.ts |   2 +-
 14 files changed, 882 insertions(+), 38 deletions(-)
 create mode 100644 apps/desktop/src/renderer/tasks/line-comment.tsx

diff --git a/apps/desktop/src/renderer/diff-view/contract.ts b/apps/desktop/src/renderer/diff-view/contract.ts
index f9b61ceea8..d79cf46df1 100644
--- a/apps/desktop/src/renderer/diff-view/contract.ts
+++ b/apps/desktop/src/renderer/diff-view/contract.ts
@@ -130,11 +130,20 @@ export interface DiffListFile {
   readonly lead: boolean;
 }
 
+/** Lines lit in one file of a list: the file, by its path, and the lines. */
+export interface DiffListSelection {
+  readonly path: string;
+  readonly selection: DiffSelection;
+}
+
 /**
  * What the view hands the bundle for a list of files: the files in order,
  * how to draw them, the element each file's header is drawn in and each
  * note, both kept by the view and filled by it, and the door told which file
- * stands at the top of the list as it scrolls.
+ * stands at the top of the list as it scrolls. Where lines may be commented
+ * on, `onComment` is told the lines a press of the gutter's + picked, on a
+ * file that draws lines of its own, and `selected` lights the lines being
+ * commented on; with no `onComment` the gutter offers nothing.
  */
 export interface DiffListProps {
   readonly files: readonly DiffListFile[];
@@ -142,6 +151,23 @@ export interface DiffListProps {
   readonly renderHeader: (path: string) => HTMLElement;
   readonly renderAnnotation: (path: string, key: string) => HTMLElement;
   readonly onTopFile: (path: string) => void;
+  readonly onComment?: ((picked: DiffListSelection) => void) | undefined;
+  readonly selected?: DiffListSelection | undefined;
+}
+
+/** Whether two lists light the same lines of the same file, or both none. */
+export function sameListSelection(
+  a: DiffListSelection | undefined,
+  b: DiffListSelection | undefined,
+): boolean {
+  if (a === undefined || b === undefined) return a === b;
+  return (
+    a.path === b.path &&
+    a.selection.start === b.selection.start &&
+    a.selection.side === b.selection.side &&
+    a.selection.end === b.selection.end &&
+    a.selection.endSide === b.selection.endSide
+  );
 }
 
 /** The list as mounted: drawn again for new props, scrolled to a file's header, and taken down. */
diff --git a/apps/desktop/src/renderer/diff-view/index.ts b/apps/desktop/src/renderer/diff-view/index.ts
index 8fa0b91bfc..62e1981977 100644
--- a/apps/desktop/src/renderer/diff-view/index.ts
+++ b/apps/desktop/src/renderer/diff-view/index.ts
@@ -11,17 +11,22 @@ import {
   type File as PierreFile,
   FileDiff as PierreFileDiff,
   type PostRenderPhase,
+  type SelectedLineRange,
 } from "@pierre/diffs";
 import { FIND_SHADOW_ATTRIBUTE } from "../find-matches";
 import {
+  DIFF_SELECTION_SIDE,
   type DiffAnnotation,
   type DiffListFile,
   type DiffListHandle,
   type DiffListProps,
+  type DiffListSelection,
   type DiffLook,
+  type DiffSelection,
   type DiffViewHandle,
   type DiffViewModule,
   type DiffViewProps,
+  sameListSelection,
   sameLook,
   sameNotes,
 } from "./contract";
@@ -296,6 +301,36 @@ interface DrawnFile {
   readonly item: CodeViewDiffItem<string>;
 }
 
+/** A range Pierre picked, in the contract's words: a side Pierre leaves unsaid is the new file's. */
+function selectionOf(range: SelectedLineRange): DiffSelection {
+  const side = range.side ?? DIFF_SELECTION_SIDE.ADDITIONS;
+  return { start: range.start, side, end: range.end, endSide: range.endSide ?? side };
+}
+
+/**
+ * Pierre's own picking of lines, where the view comments on them: a press
+ * of a line's number picks it and a ⇧-press or a drag picks a range, as
+ * GitHub's diff does, and the gutter's + on the line under the pointer, or
+ * on the range picked, tells the view, which opens its comment there. A file
+ * drawn as its notes alone has no line of its own to pick, so its pick is
+ * let go.
+ */
+function commentOptions(
+  latest: () => DiffListProps,
+  commentable: (path: string) => boolean,
+): CodeViewOptions<string, undefined> {
+  if (latest().onComment === undefined) return {};
+  return {
+    enableLineSelection: true,
+    enableGutterUtility: true,
+    lineHoverHighlight: "number",
+    onGutterUtilityClick: (range: SelectedLineRange, context: { item: { id: string } }) => {
+      const path = context.item.id;
+      if (commentable(path)) latest().onComment?.({ path, selection: selectionOf(range) });
+    },
+  };
+}
+
 /**
  * Pierre's options for a list: the look, each file's header and notes drawn
  * in the elements the view keeps for them, read off the latest props, and
@@ -305,9 +340,11 @@ function listOptions(
   drawn: DiffLook,
   latest: () => DiffListProps,
   dress: (element: HTMLElement, path: string) => void,
+  commentable: (path: string) => boolean,
 ): CodeViewOptions<string, undefined> {
   return {
     ...sharedOptions(drawn),
+    ...commentOptions(latest, commentable),
     hunkSeparators: "line-info-basic",
     stickyHeaders: true,
     itemMetrics: {
@@ -378,7 +415,10 @@ function mountList(host: HTMLElement, props: DiffListProps): DiffListHandle {
       return item;
     });
   typeset(host, props.look);
-  const view = new CodeView<string, undefined>(listOptions(props.look, () => latest, dress));
+  const commentable = (path: string) => drawnFiles.get(path)?.file.lead === false;
+  const optionsFor = (next: DiffListProps) =>
+    listOptions(next.look, () => latest, dress, commentable);
+  const view = new CodeView<string, undefined>(optionsFor(props));
   view.setup(host);
   view.setItems(itemsOf(props.files));
   view.render(true);
@@ -395,16 +435,27 @@ function mountList(host: HTMLElement, props: DiffListProps): DiffListHandle {
   };
   const unsubscribe = view.subscribeToScroll((scrollTop) => tellTop(scrollTop));
   tellTop(0);
+  // The lines being commented on, lit; Pierre's own pick stands while none is.
+  const light = (selected: DiffListSelection | undefined) => {
+    if (selected === undefined) return view.clearSelectedLines();
+    const { start, side, end, endSide } = selected.selection;
+    view.setSelectedLines({ id: selected.path, range: { start, side, end, endSide } });
+  };
+  if (props.selected !== undefined) light(props.selected);
   return {
     update: (next) => {
       const was = latest;
       latest = next;
       typeset(host, next.look);
-      if (!sameLook(next.look, was.look))
-        view.setOptions(listOptions(next.look, () => latest, dress));
+      if (
+        !sameLook(next.look, was.look) ||
+        (next.onComment === undefined) !== (was.onComment === undefined)
+      )
+        view.setOptions(optionsFor(next));
       view.setItems(itemsOf(next.files));
       view.render();
       tellTop(host.scrollTop);
+      if (!sameListSelection(next.selected, was.selected)) light(next.selected);
     },
     reveal: (path) =>
       view.scrollTo({ type: "item", id: path, align: "start", behavior: "smooth-auto" }),
diff --git a/apps/desktop/src/renderer/styles/tasks.css b/apps/desktop/src/renderer/styles/tasks.css
index 85c784d7be..ae14451eb3 100644
--- a/apps/desktop/src/renderer/styles/tasks.css
+++ b/apps/desktop/src/renderer/styles/tasks.css
@@ -1882,6 +1882,21 @@
   min-width: 0;
 }
 
+/* The pending comments the member's review holds, counted on the bar's
+   Review press as stage-cli's badge counts them. */
+.pull-request-review-count {
+  min-width: 16px;
+  margin-inline-start: var(--luke-space-4);
+  padding: 0 var(--luke-space-4);
+  border-radius: 999px;
+  background: var(--luke-color-fill-strong);
+  color: var(--luke-color-text);
+  font-size: var(--luke-type-caption-size);
+  font-variant-numeric: tabular-nums;
+  line-height: 16px;
+  text-align: center;
+}
+
 .pull-request-review-foot {
   display: flex;
   justify-content: flex-end;
@@ -2371,6 +2386,46 @@ button.pull-request-check:hover {
   background: var(--luke-color-surface);
 }
 
+/* A comment being written on lines of a file (`line-comment.tsx`), under
+   the last of them as a review thread stands: a card of the thread's own
+   face, its head naming the lines, the words with their preview, GitHub's
+   refusal, and what GitHub's own line comment offers at its foot. */
+.line-comment {
+  display: flex;
+  flex-direction: column;
+  gap: var(--luke-space-8);
+  max-width: 720px;
+  padding: var(--luke-space-8) var(--luke-space-12) var(--luke-space-12);
+  border: 1px solid var(--luke-color-border);
+  border-radius: var(--luke-control-radius);
+  background: var(--luke-color-surface);
+}
+
+.line-comment-head {
+  margin: 0;
+  color: var(--luke-color-text-muted);
+  font-size: var(--luke-type-caption-size);
+  font-weight: 600;
+}
+
+.line-comment-note {
+  margin: 0;
+  color: var(--luke-color-text-muted);
+  font-size: var(--luke-type-caption-size);
+}
+
+.line-comment-note .failure-note-words {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.line-comment-foot {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: var(--luke-control-gap);
+}
+
 .diff-outdated-threads {
   display: flex;
   flex: none;
diff --git a/apps/desktop/src/renderer/tasks/agent-changes-tab.tsx b/apps/desktop/src/renderer/tasks/agent-changes-tab.tsx
index 63725ba0e5..f6c0b97d19 100644
--- a/apps/desktop/src/renderer/tasks/agent-changes-tab.tsx
+++ b/apps/desktop/src/renderer/tasks/agent-changes-tab.tsx
@@ -7,6 +7,7 @@ import {
   type CodingAgentChangedFile,
   type CodingAgentChangesPeople,
   type CodingAgentPullRequest,
+  DIFF_SIDE,
   type ReviewThread,
 } from "@luke/features/coding-agent-wire";
 import type { CatalogModel } from "@luke/features/models-wire";
@@ -34,7 +35,12 @@ import {
 import { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { appPlatform } from "../app-platform";
 import { useCopyToast } from "../copy-feedback";
-import { DIFF_SELECTION_SIDE, type DiffSelection, FILE_NOTE_LINE } from "../diff-view/contract";
+import {
+  DIFF_SELECTION_SIDE,
+  type DiffListSelection,
+  type DiffSelection,
+  FILE_NOTE_LINE,
+} from "../diff-view/contract";
 import { SpinnerRegion } from "../spinner";
 import { Tooltip } from "../tooltip";
 import { LinesChanged } from "./agent-published";
@@ -44,6 +50,7 @@ import {
   CHANGES_WORDS,
   changedFolders,
   changeMarks,
+  commentLines,
   fileNotice,
   filePatch,
   linesChanged,
@@ -60,6 +67,7 @@ import { LinesMenu, useSaveText } from "./file-menu";
 import { FileTreePane } from "./file-tree-pane";
 import { FileViewBar, usePaneRoom } from "./file-view";
 import { useFileViewSettings } from "./file-view-settings";
+import { LineComment, type PendingReview } from "./line-comment";
 import { PullRequestMark } from "./pull-request-mark";
 import { OpenedBy, PullRequestPeople, ReviewersLine } from "./pull-request-people";
 import type { CodingAgentsControl, HeldPeople } from "./use-coding-agents";
@@ -305,12 +313,14 @@ function AboveThreads({
  * diff draws no row for above the first hunk (`threadsOn`), on the side
  * each counts on, as GitHub's split diff has them. A file with no hunks to
  * draw stands as what is said in their place alone (`lead`), across its
- * width: why it has none, and every one of its review threads.
+ * width: why it has none, and every one of its review threads. A comment
+ * being written on its lines stands under the last of them.
  */
 function entryOf(
   file: CodingAgentChangedFile,
   list: ChangesList,
   threads: ChangesThreads | undefined,
+  comment: DiffNote | undefined,
 ): DiffListEntry {
   const { placed, above } = threadsOn(threads?.list ?? [], file);
   const notice = fileNotice(file);
@@ -343,6 +353,7 @@ function entryOf(
       content: <AboveThreads above={unplaced} threads={threads} />,
     });
   }
+  if (comment !== undefined) notes.push(comment);
   const path = file.path;
   const collapsed = list.collapsed(path);
   return {
@@ -363,6 +374,79 @@ function entryOf(
   };
 }
 
+/** The key a comment being written stands under its lines by; a review thread's note is keyed by its page, which this never is. */
+const COMMENT_KEY = "line-comment";
+
+/** Where the lines a comment is on are lit and its note drawn: under the last of them, on the side that one counts on. */
+const COMMENT_SIDE = {
+  [DIFF_SIDE.LEFT]: DIFF_SELECTION_SIDE.DELETIONS,
+  [DIFF_SIDE.RIGHT]: DIFF_SELECTION_SIDE.ADDITIONS,
+} as const;
+
+/** What the list is handed of commenting: where the gutter's + opens a comment, and the one open, its lines lit and its note. */
+interface ListCommenting {
+  readonly open: (picked: DiffListSelection) => void;
+  readonly note:
+    | { readonly path: string; readonly picked: DiffListSelection; readonly content: DiffNote }
+    | undefined;
+}
+
+/** How Files changed comments on lines, where its Pull request tab lets it: the member's pending review, which names the offers, and what reads the tab again once GitHub answered. */
+export interface LineComments {
+  readonly pending: PendingReview;
+  readonly onWritten: () => void;
+}
+
+/**
+ * The comment being written on lines of the files, one at a time as
+ * GitHub's own diff opens one, and each file's words kept for it while the
+ * tab stands; none open until the gutter's + picks lines GitHub would take
+ * a comment on (`commentLines`).
+ */
+function useListCommenting(
+  agentId: string,
+  files: readonly CodingAgentChangedFile[],
+  headSha: string | undefined,
+  comments: LineComments | undefined,
+  onRefresh: () => void,
+): ListCommenting | undefined {
+  const [picked, setPicked] = useState<DiffListSelection | undefined>(undefined);
+  const [words, setWords] = useState<ReadonlyMap<string, string>>(new Map());
+  const open = useCallback(
+    (next: DiffListSelection) => {
+      const file = files.find((each) => each.path === next.path);
+      if (file !== undefined && commentLines(file, next.selection) !== undefined) setPicked(next);
+    },
+    [files],
+  );
+  if (comments === undefined) return undefined;
+  const file = picked === undefined ? undefined : files.find((each) => each.path === picked.path);
+  const lines =
+    file === undefined || picked === undefined ? undefined : commentLines(file, picked.selection);
+  if (picked === undefined || lines === undefined) return { open, note: undefined };
+  const { path } = picked;
+  const content: DiffNote = {
+    key: COMMENT_KEY,
+    side: COMMENT_SIDE[lines.side],
+    line: lines.line,
+    content: (
+      <LineComment
+        agentId={agentId}
+        path={path}
+        lines={lines}
+        headSha={headSha}
+        pending={comments.pending}
+        body={words.get(path) ?? ""}
+        onBody={(body) => setWords((was) => new Map(was).set(path, body))}
+        onClose={() => setPicked(undefined)}
+        onWritten={comments.onWritten}
+        onRefresh={onRefresh}
+      />
+    ),
+  };
+  return { open, note: { path, picked, content } };
+}
+
 /** Collapse all or Expand all, for the files the filter keeps, in the bar. */
 function FoldAllButton({ list }: { list: ChangesList }): React.JSX.Element {
   const label = list.allCollapsed ? LIST_WORDS.EXPAND_ALL : LIST_WORDS.COLLAPSE_ALL;
@@ -389,12 +473,15 @@ function FoldAllButton({ list }: { list: ChangesList }): React.JSX.Element {
 function FilesList({
   list,
   threads,
+  commenting,
   filterShown,
   roomy,
   boxRef,
 }: {
   list: ChangesList;
   threads: ChangesThreads | undefined;
+  /** The comment being written, and where the gutter's + opens one; none offers no +. */
+  commenting: ListCommenting | undefined;
   /** Whether the tree, whose search is the filter, is drawn, so the filter is in sight. */
   filterShown: boolean;
   roomy: boolean;
@@ -418,11 +505,20 @@ function FilesList({
         <p className="side-panel-empty">{LIST_WORDS.NONE_KEPT}</p>
       ) : (
         <PierreDiffList
-          entries={list.kept.map((file) => entryOf(file, list, threads))}
+          entries={list.kept.map((file) =>
+            entryOf(
+              file,
+              list,
+              threads,
+              commenting?.note?.path === file.path ? commenting.note.content : undefined,
+            ),
+          )}
           look={look}
           door={list.door}
           onTopFile={list.onTopFile}
           boxRef={boxRef}
+          onComment={commenting?.open}
+          selected={commenting?.note?.picked}
         />
       )}
     </section>
@@ -503,6 +599,7 @@ export function AgentChangesTab({
   repository,
   tree,
   threads,
+  lineComments,
 }: {
   agentId: string;
   control: CodingAgentsControl;
@@ -514,6 +611,8 @@ export function AgentChangesTab({
   tree: { readonly open: boolean; readonly onToggle: () => void };
   /** The pull request's review threads, drawn on their lines in each file's diff; none draws none. */
   threads?: ChangesThreads | undefined;
+  /** How a comment on lines is made, where the tab lets one be; none offers no comment. */
+  lineComments?: LineComments | undefined;
 }): React.JSX.Element {
   const status = control.agents?.find((each) => each.id === agentId)?.status;
   const ended = !agentStillWriting(status ?? CODING_AGENT_STATUS.RUNNING);
@@ -541,6 +640,17 @@ export function AgentChangesTab({
     [closeOver, go],
   );
   const shownFile = changed.files.find((file) => file.path === list.current) ?? changed.files[0];
+  const refresh = () => {
+    ask();
+    threads?.refresh?.();
+  };
+  const commenting = useListCommenting(
+    agentId,
+    changed.files,
+    pullRequest?.headSha,
+    lineComments,
+    refresh,
+  );
   // A failure gives way to the wait as soon as it is asked again; files drawn stand until the answer lands.
   if (answer === undefined || (out && "failure" in answer)) {
     return <SpinnerRegion label={CHANGES_WORDS.READING} />;
@@ -596,15 +706,7 @@ export function AgentChangesTab({
           <>
             <DiffSettingsButton roomy={roomy} />
             <FoldAllButton list={list} />
-            <ChangesMenu
-              file={shownFile}
-              reading={out}
-              onRefresh={() => {
-                ask();
-                threads?.refresh?.();
-              }}
-              roomy={roomy}
-            />
+            <ChangesMenu file={shownFile} reading={out} onRefresh={refresh} roomy={roomy} />
           </>
         }
         tree={room.toggles}
@@ -619,6 +721,7 @@ export function AgentChangesTab({
         <FilesList
           list={list}
           threads={threads}
+          commenting={commenting}
           filterShown={room.drawn}
           roomy={roomy}
           boxRef={setDiffBox}
diff --git a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
index f8f0a2c615..49bc42a1c4 100644
--- a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
+++ b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
@@ -38,6 +38,7 @@ import {
   PULL_REQUEST_WRITE_OUTCOME,
   type PullRequestActionRequest,
   type PullRequestWriteAnswer,
+  REVIEW_COMMENT_MODE,
   REVIEW_EVENT,
 } from "@luke/features/pull-request-write-wire";
 import { WORKSPACE_ROLE, type WorkspaceMember } from "@luke/features/workspace-wire";
@@ -57,7 +58,13 @@ import { markdownHtmlParserLanded } from "#testing/markdown";
 import { landedBundles, onSideBundles } from "#testing/side-bundles";
 import { codingAgentsControl } from "#testing/tasks-control";
 import type { SideBundles } from "../bundle-loader";
-import type { DiffListProps, DiffViewModule, DiffViewProps } from "../diff-view/contract";
+import {
+  DIFF_SELECTION_SIDE,
+  type DiffListProps,
+  type DiffListSelection,
+  type DiffViewModule,
+  type DiffViewProps,
+} from "../diff-view/contract";
 import { type GitHubConnectControl, GitHubConnectProvider } from "../github-connect";
 import { MemberDirectory } from "../member-directory";
 import { rendererRuntime } from "../renderer-runtime";
@@ -2674,3 +2681,211 @@ test("a comment being written outlives a read of the conversation that failed, s
     "Half a thought",
   );
 });
+
+/** The head the changes were read at, which a comment on their lines names. */
+const READ_HEAD = "c0ffee1c0ffee1c0ffee1c0ffee1c0ffee1c0ffe";
+
+/** One changed file whose hunk is the review threads' own: old lines 8–12, the last removed, and new lines 8–13, the last two added. */
+const INVITE_FILE = {
+  path: "src/invite.ts",
+  previousPath: null,
+  status: CHANGED_FILE_STATUS.MODIFIED,
+  additions: 2,
+  deletions: 1,
+  omitted: null,
+  patch: thread().diffHunk.replace("@@ -8,6 +8,7 @@", "@@ -8,5 +8,6 @@"),
+};
+
+/** The tab over that one file, read at `READ_HEAD`, its conversation holding the member's pending review as given, and how many times the changes were read. */
+async function drawCommentable(pendingReview?: { readonly comments: number } | null) {
+  const read = { changes: 0 };
+  const tab = await draw(
+    controlAnswering(
+      {
+        conversation: () =>
+          Promise.resolve({
+            pullRequest: {
+              ...CONVERSATION,
+              ...(pendingReview === undefined ? undefined : { pendingReview }),
+            },
+          }),
+      },
+      PULL_REQUEST_STATE.OPEN,
+      () => {
+        read.changes += 1;
+        return Promise.resolve({
+          pullRequest: { url: PAGE, headSha: READ_HEAD, truncated: false, files: [INVITE_FILE] },
+        });
+      },
+    ),
+  );
+  await act(async () => option(tab, "Files changed").click());
+  await settle();
+  return { tab, read };
+}
+
+/** Presses the gutter's + on the lines given of the file, as the diff bundle tells the view, and the comment it opened. */
+async function pickLines(selection: DiffListSelection["selection"]): Promise<HTMLElement> {
+  const drawn = lists.at(-1) ?? assert.fail("the files are drawn");
+  const onComment = drawn.onComment ?? assert.fail("the gutter offers a comment");
+  act(() => onComment({ path: INVITE_FILE.path, selection }));
+  await settle();
+  return (lists.at(-1) ?? drawn).renderAnnotation(INVITE_FILE.path, "line-comment");
+}
+
+/** Writes the comment's words as the member would. */
+function writeLineComment(comment: HTMLElement, words: string): void {
+  const field =
+    comment.querySelector<HTMLTextAreaElement>('textarea[aria-label="Comment"]') ??
+    assert.fail("the comment has a field for its words");
+  act(() => {
+    const set = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, "value")?.set;
+    set?.call(field, words);
+    field.dispatchEvent(new Event("input", { bubbles: true }));
+  });
+}
+
+/** The comment's press of the words given. */
+function commentOffer(comment: HTMLElement, label: string): HTMLButtonElement {
+  return (
+    [...comment.querySelectorAll<HTMLButtonElement>("button")].find(
+      (each) => each.textContent === label,
+    ) ?? assert.fail(`the comment offers ${label}`)
+  );
+}
+
+/** Whether the files' last draw stands a comment under a line. */
+function commentDrawn(): boolean {
+  return (lists.at(-1)?.files ?? []).some((file) =>
+    file.annotations.some((note) => note.key === "line-comment"),
+  );
+}
+
+test("the gutter's + opens a comment under the last line picked, however the pick was dragged, its lines lit; Add single comment sends it for the agent at the head the files were read at, after which it closes and lets its words go", async () => {
+  await drawCommentable();
+
+  const comment = await pickLines({
+    start: 13,
+    side: DIFF_SELECTION_SIDE.ADDITIONS,
+    end: 12,
+    endSide: DIFF_SELECTION_SIDE.ADDITIONS,
+  });
+
+  assert.equal(comment.querySelector(".line-comment-head")?.textContent, "Comment on lines 12–13");
+  assert.deepEqual(
+    lists.at(-1)?.files[0]?.annotations.find((note) => note.key === "line-comment"),
+    { key: "line-comment", side: DIFF_SELECTION_SIDE.ADDITIONS, line: 13 },
+  );
+  assert.equal(lists.at(-1)?.selected?.path, INVITE_FILE.path);
+  assert.deepEqual(
+    [...comment.querySelectorAll(".line-comment-foot button")].map((each) => each.textContent),
+    ["Cancel", "Add single comment", "Start a review"],
+  );
+
+  writeLineComment(comment, "Why **twice**?");
+  act(() => commentOffer(comment, "Add single comment").click());
+  await settle();
+
+  assert.deepEqual(changes, [
+    [
+      AGENT.id,
+      {
+        action: PULL_REQUEST_ACTION.ADD_REVIEW_COMMENT,
+        mode: REVIEW_COMMENT_MODE.SINGLE,
+        path: INVITE_FILE.path,
+        line: 13,
+        side: DIFF_SIDE.RIGHT,
+        startLine: 12,
+        startSide: DIFF_SIDE.RIGHT,
+        body: "Why **twice**?",
+        headSha: READ_HEAD,
+      },
+    ],
+  ]);
+  assert.equal(commentDrawn(), false, "the comment closes once GitHub took it");
+  assert.equal(lists.at(-1)?.selected, undefined, "its lines are no longer lit");
+  const again = await pickLines({
+    start: 12,
+    side: DIFF_SELECTION_SIDE.DELETIONS,
+    end: 12,
+    endSide: DIFF_SELECTION_SIDE.DELETIONS,
+  });
+  assert.equal(again.querySelector("textarea")?.value, "", "its words were let go");
+  assert.equal(again.querySelector(".line-comment-head")?.textContent, "Comment on line 12");
+});
+
+test("a member holding a pending review adds a comment to it and nothing else, and Review counts its comments and offers to discard it, asking first", async () => {
+  const { tab } = await drawCommentable({ comments: 2 });
+
+  const comment = await pickLines({
+    start: 12,
+    side: DIFF_SELECTION_SIDE.DELETIONS,
+    end: 12,
+    endSide: DIFF_SELECTION_SIDE.DELETIONS,
+  });
+  assert.deepEqual(
+    [...comment.querySelectorAll(".line-comment-foot button")].map((each) => each.textContent),
+    ["Cancel", "Add review comment"],
+  );
+  writeLineComment(comment, "Gone?");
+  act(() => commentOffer(comment, "Add review comment").click());
+  await settle();
+
+  const review =
+    tab.querySelector<HTMLButtonElement>('[aria-label="Review, 2 pending comments"]') ??
+    assert.fail("Review counts the pending comments");
+  act(() => review.click());
+  const panel =
+    tab.querySelector<HTMLElement>('[role="dialog"]') ?? assert.fail("Review opens its panel");
+  assert.match(panel.textContent ?? "", /2 pending comments will be published\./u);
+  act(() => commentOffer(panel, "Discard").click());
+  const question =
+    document.querySelector<HTMLElement>('[role="alertdialog"]') ??
+    assert.fail("Discard asks first");
+  act(() => commentOffer(question, "Discard review").click());
+  await settle();
+
+  assert.deepEqual(
+    changes.map(([, request]) => request),
+    [
+      {
+        action: PULL_REQUEST_ACTION.ADD_REVIEW_COMMENT,
+        mode: REVIEW_COMMENT_MODE.REVIEW,
+        path: INVITE_FILE.path,
+        line: 12,
+        side: DIFF_SIDE.LEFT,
+        body: "Gone?",
+        headSha: READ_HEAD,
+      },
+      { action: PULL_REQUEST_ACTION.DISCARD_REVIEW },
+    ],
+  );
+});
+
+test("a comment GitHub refuses says so under it in GitHub's own words, its words kept, beside Refresh changes, which reads the files again", async () => {
+  changeAnswer = {
+    outcome: PULL_REQUEST_WRITE_OUTCOME.REFUSED,
+    words: "Pull request review thread line must be part of the diff",
+  };
+  const { read } = await drawCommentable();
+  const comment = await pickLines({
+    start: 9,
+    side: DIFF_SELECTION_SIDE.ADDITIONS,
+    end: 9,
+    endSide: DIFF_SELECTION_SIDE.ADDITIONS,
+  });
+
+  writeLineComment(comment, "Here.");
+  act(() => commentOffer(comment, "Start a review").click());
+  await settle();
+
+  assert.equal(
+    comment.querySelector(".line-comment-note .failure-note-words")?.textContent,
+    "GitHub said: Pull request review thread line must be part of the diff",
+  );
+  assert.equal(comment.querySelector("textarea")?.value, "Here.");
+  const before = read.changes;
+  act(() => commentOffer(comment, "Refresh changes").click());
+  await settle();
+  assert.equal(read.changes, before + 1);
+});
diff --git a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx
index 7023f9e5b2..2dfd6e1183 100644
--- a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx
+++ b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.tsx
@@ -90,6 +90,7 @@ import {
 } from "./conversation-filters";
 import { PierreDiff, useDiffLook } from "./file-diff";
 import { useFileViewSettings } from "./file-view-settings";
+import type { PendingReview } from "./line-comment";
 import { blockedWords, MergeActions } from "./merge-box";
 import {
   type PullRequestComment,
@@ -478,6 +479,7 @@ function PullRequestBar({
   published,
   writes,
   review,
+  pending,
   reading,
   onRefresh,
 }: {
@@ -485,6 +487,8 @@ function PullRequestBar({
   writes: PullRequestWrites;
   /** The review's own change, apart from the pill's, so each says its own answer where it was pressed. */
   review: PullRequestWrites;
+  /** The member's own pending review, which the Review panel publishes or discards. */
+  pending: PendingReview;
   /** Whether a read is out, which a refresh would only repeat. */
   reading: boolean;
   onRefresh: () => void;
@@ -497,7 +501,7 @@ function PullRequestBar({
           <div className="file-view-actions">
             {published.state === PULL_REQUEST_STATE.OPEN ||
             published.state === PULL_REQUEST_STATE.DRAFT ? (
-              <PullRequestReview writes={review} />
+              <PullRequestReview writes={review} pending={pending} />
             ) : null}
             <Tooltip label="Open on GitHub">
               <IconButton
@@ -1645,6 +1649,8 @@ export function AgentPullRequestTab({
   const written = refresh;
   const writes = usePullRequestWrites(agentId, written);
   const review = usePullRequestWrites(agentId, written);
+  // The member's own pending review, read beside the conversation, which names what Review and a comment on lines offer.
+  const pendingReview = landed(parts.conversation)?.pendingReview;
   const picture = usePictureDrawer(agentId);
   const comment = usePullRequestComment(agentId, written);
   // Every review thread the tab draws, in the Conversation or on its line, replies and resolves on this agent's pull request.
@@ -1655,6 +1661,7 @@ export function AgentPullRequestTab({
           published={bar}
           writes={writes}
           review={review}
+          pending={pendingReview}
           reading={reading}
           onRefresh={refresh}
         />
@@ -1728,6 +1735,7 @@ export function AgentPullRequestTab({
               ),
               refresh: ask.conversation,
             }}
+            lineComments={{ pending: pendingReview, onWritten: written }}
           />
         </div>
       </div>
diff --git a/apps/desktop/src/renderer/tasks/changes-model.test.ts b/apps/desktop/src/renderer/tasks/changes-model.test.ts
index ac9a60d6e5..2dc65c8fbf 100644
--- a/apps/desktop/src/renderer/tasks/changes-model.test.ts
+++ b/apps/desktop/src/renderer/tasks/changes-model.test.ts
@@ -6,7 +6,16 @@ import {
   PATCH_OMITTED,
 } from "@luke/features/coding-agent-wire";
 import { test } from "vitest";
-import { filterFiles, startsCollapsed, threadPreview, threadsOn, treeOrder } from "./changes-model";
+import { DIFF_SELECTION_SIDE } from "../diff-view/contract";
+import {
+  commentLines,
+  commentLinesLabel,
+  filterFiles,
+  startsCollapsed,
+  threadPreview,
+  threadsOn,
+  treeOrder,
+} from "./changes-model";
 
 /**
  * changes-model.test.ts -- a review thread previews the end of the hunk
@@ -270,3 +279,60 @@ test("a deleted file, a lockfile, and a file of more than a thousand changed lin
     false,
   );
 });
+
+/** A pick of lines on the sides given, from `start` to `end`, as the gutter's + tells it. */
+function picked(
+  start: number,
+  end: number,
+  side: (typeof DIFF_SELECTION_SIDE)[keyof typeof DIFF_SELECTION_SIDE] = DIFF_SELECTION_SIDE.ADDITIONS,
+  endSide = side,
+) {
+  return { start, side, end, endSide };
+}
+
+test("a comment's lines are GitHub's: in the order the diff draws them however they were picked, one line where both ends are one row, and each end on its own side", () => {
+  assert.deepEqual(commentLines(FILE_A, picked(5, 3)), {
+    line: 5,
+    side: DIFF_SIDE.RIGHT,
+    startLine: 3,
+    startSide: DIFF_SIDE.RIGHT,
+  });
+  assert.deepEqual(commentLines(FILE_A, picked(4, 4, DIFF_SELECTION_SIDE.DELETIONS)), {
+    line: 4,
+    side: DIFF_SIDE.LEFT,
+  });
+  assert.deepEqual(
+    commentLines(
+      FILE_A,
+      picked(5, 4, DIFF_SELECTION_SIDE.ADDITIONS, DIFF_SELECTION_SIDE.DELETIONS),
+    ),
+    { line: 5, side: DIFF_SIDE.RIGHT, startLine: 4, startSide: DIFF_SIDE.LEFT },
+  );
+  assert.deepEqual(
+    commentLines(FILE_A, picked(5, 5, DIFF_SELECTION_SIDE.DELETIONS)),
+    { line: 5, side: DIFF_SIDE.LEFT },
+    "an unchanged line counts on the old side too",
+  );
+  assert.equal(
+    commentLinesLabel({ line: 5, side: DIFF_SIDE.RIGHT, startLine: 3, startSide: DIFF_SIDE.RIGHT }),
+    "lines 3–5",
+  );
+  assert.equal(
+    commentLinesLabel({ line: 5, side: DIFF_SIDE.RIGHT, startLine: 4, startSide: DIFF_SIDE.LEFT }),
+    "lines L4–R5",
+  );
+});
+
+test("no comment is offered where GitHub takes none: a line no row stands for, a range across two hunks, or a file that draws no lines of its own", () => {
+  const twoHunks = changed("src/two.ts", {
+    patch: "@@ -1,2 +1,2 @@\n-a\n+b\n c\n@@ -10,2 +10,2 @@\n x\n-y\n+z",
+  });
+
+  assert.equal(commentLines(FILE_A, picked(9, 9)), undefined);
+  assert.equal(commentLines(FILE_A, picked(6, 6, DIFF_SELECTION_SIDE.DELETIONS)), undefined);
+  assert.equal(commentLines(twoHunks, picked(1, 11)), undefined);
+  assert.equal(
+    commentLines(changed("logo.png", { patch: null, omitted: PATCH_OMITTED.BINARY }), picked(1, 1)),
+    undefined,
+  );
+});
diff --git a/apps/desktop/src/renderer/tasks/changes-model.ts b/apps/desktop/src/renderer/tasks/changes-model.ts
index 84df86a4b4..b5944d9db3 100644
--- a/apps/desktop/src/renderer/tasks/changes-model.ts
+++ b/apps/desktop/src/renderer/tasks/changes-model.ts
@@ -528,3 +528,77 @@ export function startsCollapsed(file: CodingAgentChangedFile): boolean {
     LOCKFILE_NAMES.has(file.path.split("/").at(-1) ?? "")
   );
 }
+
+/** The lines a comment is on, as GitHub takes them: its last line and the side it counts on, and, for more than one, its first and that one's side. */
+export interface CommentLines {
+  readonly line: number;
+  readonly side: DiffSide;
+  readonly startLine?: number;
+  readonly startSide?: DiffSide;
+}
+
+/** A selection's side as GitHub's: the old side's lines on the left, the new side's on the right. */
+const GITHUB_SIDE = {
+  [DIFF_SELECTION_SIDE.DELETIONS]: DIFF_SIDE.LEFT,
+  [DIFF_SELECTION_SIDE.ADDITIONS]: DIFF_SIDE.RIGHT,
+} as const satisfies Record<DiffSelection["side"], DiffSide>;
+
+/** Where a picked line stands among a file's hunks: which hunk, and which of its rows; none where no row stands for it. */
+function rowAt(
+  hunks: readonly DiffHunk[],
+  side: DiffSelection["side"],
+  line: number,
+): { readonly hunk: number; readonly row: number } | undefined {
+  for (const [hunk, { rows }] of hunks.entries()) {
+    const row = rows.findIndex((each) =>
+      side === DIFF_SELECTION_SIDE.DELETIONS
+        ? each.kind !== DIFF_ROW.ADDED && each.oldLine === line
+        : each.newLine === line,
+    );
+    if (row !== -1) return { hunk, row };
+  }
+  return undefined;
+}
+
+/**
+ * The lines a comment picked in a file's diff is on, as GitHub takes them,
+ * in the order the diff draws them, however the pick was dragged; one line
+ * where both ends are the same row. None where GitHub would take no comment
+ * there: a file that draws no hunks of its own, binary, too large, or an
+ * image drawn in their place, a line no row of the diff stands for, or a
+ * range whose ends stand in two hunks, which GitHub refuses.
+ */
+export function commentLines(
+  file: CodingAgentChangedFile,
+  picked: DiffSelection,
+): CommentLines | undefined {
+  if (fileNotice(file) !== undefined || file.patch === null) return undefined;
+  const hunks = patchHunks(file.patch) ?? [];
+  const from = rowAt(hunks, picked.side, picked.start);
+  const to = rowAt(hunks, picked.endSide, picked.end);
+  if (from === undefined || to === undefined || from.hunk !== to.hunk) return undefined;
+  const [first, last] =
+    from.row <= to.row
+      ? [
+          { line: picked.start, side: picked.side },
+          { line: picked.end, side: picked.endSide },
+        ]
+      : [
+          { line: picked.end, side: picked.endSide },
+          { line: picked.start, side: picked.side },
+        ];
+  const end = { line: last.line, side: GITHUB_SIDE[last.side] };
+  return from.row === to.row
+    ? end
+    : { ...end, startLine: first.line, startSide: GITHUB_SIDE[first.side] };
+}
+
+/** The lines a comment is on, as its composer names them: "line 12", or "lines 10–12" with each side's mark where the two ends count on different sides. */
+export function commentLinesLabel(lines: CommentLines): string {
+  const mark = (line: number, side: DiffSide) =>
+    lines.startSide === undefined || lines.startSide === lines.side
+      ? `${line}`
+      : `${side === DIFF_SIDE.LEFT ? "L" : "R"}${line}`;
+  if (lines.startLine === undefined) return `line ${lines.line}`;
+  return `lines ${mark(lines.startLine, lines.startSide ?? lines.side)}–${mark(lines.line, lines.side)}`;
+}
diff --git a/apps/desktop/src/renderer/tasks/diff-list.tsx b/apps/desktop/src/renderer/tasks/diff-list.tsx
index 51624edc91..57cac90089 100644
--- a/apps/desktop/src/renderer/tasks/diff-list.tsx
+++ b/apps/desktop/src/renderer/tasks/diff-list.tsx
@@ -8,7 +8,9 @@ import {
   type DiffListFile,
   type DiffListHandle,
   type DiffListProps,
+  type DiffListSelection,
   type DiffLook,
+  sameListSelection,
   sameLook,
   sameNotes,
 } from "../diff-view/contract";
@@ -24,7 +26,9 @@ import {
  * the file and under its line, so a header and a note are this window's own
  * React and stylesheets. The view is told the file whose header stands at
  * the top as the list scrolls, and scrolls the list to a file through
- * `door`.
+ * `door`. Where the view comments on lines, the gutter's + tells it the
+ * lines picked (`onComment`), and the lines it is commenting on stand lit
+ * (`selected`).
  */
 
 /** A note drawn in a file of the list, a review thread's under its line or what stands above the file's first hunk: where it stands, and what it says. */
@@ -91,6 +95,8 @@ export function PierreDiffList({
   door,
   onTopFile,
   boxRef,
+  onComment,
+  selected,
 }: {
   entries: readonly DiffListEntry[];
   look: DiffLook;
@@ -100,6 +106,10 @@ export function PierreDiffList({
   onTopFile: (path: string) => void;
   /** Handed the box the list is drawn in, which the view measures for a split's room; a door that stays the same, as a state's setter does. */
   boxRef: (element: HTMLDivElement | null) => void;
+  /** Told the lines a press of the gutter's + picked; none offers no +. */
+  onComment?: ((picked: DiffListSelection) => void) | undefined;
+  /** The lines being commented on, lit. */
+  selected?: DiffListSelection | undefined;
 }): React.JSX.Element {
   const loaded = useAtomValue(useSideBundles().diffView);
   const module = AsyncResult.isSuccess(loaded) ? loaded.value : undefined;
@@ -122,6 +132,9 @@ export function PierreDiffList({
   const topFile = useRef(onTopFile);
   topFile.current = onTopFile;
   const tellTop = useCallback((path: string) => topFile.current(path), []);
+  const comment = useRef(onComment);
+  comment.current = onComment;
+  const tellComment = useCallback((picked: DiffListSelection) => comment.current?.(picked), []);
   const files = entries.map((entry) => ({
     path: entry.path,
     patch: entry.patch,
@@ -129,7 +142,15 @@ export function PierreDiffList({
     lead: entry.lead,
     annotations: entry.notes.map(placeOf),
   }));
-  const props: DiffListProps = { files, look, renderHeader, renderAnnotation, onTopFile: tellTop };
+  const props: DiffListProps = {
+    files,
+    look,
+    renderHeader,
+    renderAnnotation,
+    onTopFile: tellTop,
+    onComment: onComment === undefined ? undefined : tellComment,
+    selected,
+  };
   // What the list was last drawn with; the mount reads the latest, so it is mounted once.
   const drawn = useRef(props);
   const latest = useRef(props);
@@ -159,7 +180,13 @@ export function PierreDiffList({
   useEffect(() => {
     if (handle.current === undefined) return;
     const was = drawn.current;
-    if (sameFiles(was.files, files) && sameLook(was.look, look)) return;
+    if (
+      sameFiles(was.files, files) &&
+      sameLook(was.look, look) &&
+      sameListSelection(was.selected, selected) &&
+      (was.onComment === undefined) === (onComment === undefined)
+    )
+      return;
     drawn.current = latest.current;
     handle.current.update(latest.current);
   });
diff --git a/apps/desktop/src/renderer/tasks/line-comment.tsx b/apps/desktop/src/renderer/tasks/line-comment.tsx
new file mode 100644
index 0000000000..8958f5f304
--- /dev/null
+++ b/apps/desktop/src/renderer/tasks/line-comment.tsx
@@ -0,0 +1,158 @@
+import {
+  PULL_REQUEST_ACTION,
+  REVIEW_COMMENT_MODE,
+  type ReviewCommentMode,
+} from "@luke/features/pull-request-write-wire";
+import { BUTTON_VARIANT, Button } from "@luke/ui";
+import { useEffect, useRef, useState } from "react";
+import { type CommentLines, commentLinesLabel } from "./changes-model";
+import { MarkdownField } from "./markdown-field";
+import { PullRequestWriteNote, usePullRequestWrites, WRITE_NOTE } from "./pull-request-writes";
+
+/**
+ * line-comment.tsx -- the comment a member writes on lines of a changed file in Files changed, drawn under the last of them as GitHub's own line comment is.
+ *
+ * It opens where the gutter's + was pressed, on the line under the pointer
+ * or the lines picked (`changes-model.ts`'s `commentLines`), and offers what
+ * GitHub's own does: Add single comment, published at once as a review of
+ * its own, and Start a review, which holds it in the member's pending
+ * review until the Review panel submits it; where the member already holds
+ * a pending review, Add review comment adds it there, as GitHub offers
+ * nothing else then. Each is one change (`PULL_REQUEST_ACTION.ADD_REVIEW_COMMENT`),
+ * made on GitHub by the service as the member pressing it, on their own
+ * sign-in, at the head the files were read at, so a comment lands on the
+ * lines the member saw. Once GitHub took it the comment lets its words go
+ * and closes, and the tab reads the conversation again, which draws the
+ * comment on its line and counts the pending review; GitHub's refusal
+ * stands under it in GitHub's words, beside Refresh changes, since a head
+ * pushed since is the likeliest why. The words are the view's, kept by the
+ * file, so a comment scrolled out of the list and back loses nothing.
+ */
+
+/** The comment's own words. */
+const LINE_WORDS = {
+  FIELD: "Comment",
+  PLACEHOLDER: "Leave a comment in Markdown…",
+  CANCEL: "Cancel",
+  SINGLE: "Add single comment",
+  START: "Start a review",
+  ADD: "Add review comment",
+  SENDING: "Commenting",
+  REFRESH: "Refresh changes",
+  NO_HEAD: "Refresh changes to comment on these lines.",
+  /** What the comment's head says of the lines it is on. */
+  on: (lines: string) => `Comment on ${lines}`,
+} as const;
+
+/** The member's own pending review, as the conversation's read counts it: none held, or how many comments it holds; unknown before the read lands or where it could not be read as theirs. */
+export type PendingReview = { readonly comments: number } | null | undefined;
+
+/**
+ * The comment under the lines it is on: its head naming them, the words
+ * with their preview, GitHub's answer where it did not take it, and Cancel
+ * with what GitHub offers. ⌘↩ sends it the way the first offer does, and
+ * Escape lets it go unless it is on its way.
+ */
+export function LineComment({
+  agentId,
+  path,
+  lines,
+  headSha,
+  pending,
+  body,
+  onBody,
+  onClose,
+  onWritten,
+  onRefresh,
+}: {
+  agentId: string;
+  path: string;
+  lines: CommentLines;
+  /** The head the files were read at, which the comment is anchored to; none where it could not be read, which offers nothing but Refresh. */
+  headSha: string | undefined;
+  pending: PendingReview;
+  body: string;
+  onBody: (body: string) => void;
+  onClose: () => void;
+  /** Reads the tab again once GitHub answered. */
+  onWritten: () => void;
+  /** Reads the changes again. */
+  onRefresh: () => void;
+}): React.JSX.Element {
+  const writes = usePullRequestWrites(agentId, onWritten);
+  // Which offer sent the comment out, which alone wears the wait.
+  const [sentAs, setSentAs] = useState<ReviewCommentMode | undefined>(undefined);
+  const field = useRef<HTMLTextAreaElement>(null);
+  const sending = writes.pending !== undefined;
+  const blank = body.trim() === "";
+  const holding = pending != null;
+  const send = (mode: ReviewCommentMode) => {
+    if (blank || sending || headSha === undefined) return;
+    setSentAs(mode);
+    writes.write(
+      { action: PULL_REQUEST_ACTION.ADD_REVIEW_COMMENT, mode, path, ...lines, body, headSha },
+      () => {
+        onBody("");
+        onClose();
+      },
+    );
+  };
+  const first = holding ? REVIEW_COMMENT_MODE.REVIEW : REVIEW_COMMENT_MODE.SINGLE;
+
+  useEffect(() => {
+    field.current?.focus();
+  }, []);
+
+  return (
+    // biome-ignore lint/a11y/noStaticElementInteractions: Escape anywhere in the comment lets it go, as it does in GitHub's own.
+    <div
+      className="line-comment"
+      onKeyDown={(event) => {
+        if (event.key !== "Escape" || sending) return;
+        event.preventDefault();
+        event.stopPropagation();
+        onClose();
+      }}
+    >
+      <p className="line-comment-head">{LINE_WORDS.on(commentLinesLabel(lines))}</p>
+      <MarkdownField
+        label={LINE_WORDS.FIELD}
+        placeholder={LINE_WORDS.PLACEHOLDER}
+        value={body}
+        onChange={onBody}
+        busy={sending}
+        fieldRef={field}
+        onSubmit={() => send(first)}
+      />
+      {headSha === undefined ? <p className="line-comment-note">{LINE_WORDS.NO_HEAD}</p> : null}
+      <PullRequestWriteNote writes={writes} className="line-comment-note" />
+      <div className="line-comment-foot">
+        {headSha === undefined || writes.note?.kind === WRITE_NOTE.WORDS ? (
+          <Button onClick={onRefresh}>{LINE_WORDS.REFRESH}</Button>
+        ) : null}
+        <Button disabled={sending} onClick={onClose}>
+          {LINE_WORDS.CANCEL}
+        </Button>
+        {holding ? null : (
+          <Button
+            disabled={blank || headSha === undefined}
+            busy={sending && sentAs === REVIEW_COMMENT_MODE.SINGLE}
+            busyLabel={LINE_WORDS.SENDING}
+            onClick={() => send(REVIEW_COMMENT_MODE.SINGLE)}
+          >
+            {LINE_WORDS.SINGLE}
+          </Button>
+        )}
+        <Button
+          variant={BUTTON_VARIANT.PRIMARY}
+          disabled={blank || headSha === undefined}
+          busy={sending && sentAs === REVIEW_COMMENT_MODE.REVIEW}
+          busyLabel={LINE_WORDS.SENDING}
+          onClick={() => send(REVIEW_COMMENT_MODE.REVIEW)}
+        >
+          {holding ? LINE_WORDS.ADD : LINE_WORDS.START}
+        </Button>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/tasks/pull-request-review.tsx b/apps/desktop/src/renderer/tasks/pull-request-review.tsx
index e33266d6af..d8996ef405 100644
--- a/apps/desktop/src/renderer/tasks/pull-request-review.tsx
+++ b/apps/desktop/src/renderer/tasks/pull-request-review.tsx
@@ -9,11 +9,17 @@ import {
   Button,
   ChoiceList,
   type ChoiceOption,
+  ConfirmDialog,
+  type DialogQuestion,
   POPOVER_ALIGN,
+  useConfirmDialog,
 } from "@luke/ui";
-import { MessageSquarePlusIcon } from "lucide-react";
+import { CONFIRM_STAGE } from "@luke/ui/confirm-state";
+import { ACTION_RESULT_STATUS } from "@luke/wire";
+import { MessageSquarePlusIcon, Trash2Icon } from "lucide-react";
 import { useEffect, useId, useRef, useState } from "react";
 import { PopoverPanel } from "../popover-panel";
+import type { PendingReview } from "./line-comment";
 import { MarkdownField } from "./markdown-field";
 import { PullRequestWriteNote, type PullRequestWrites } from "./pull-request-writes";
 
@@ -45,8 +51,22 @@ const REVIEW_WORDS = {
   CANCEL: "Cancel",
   SUBMIT: "Submit review",
   SUBMITTING: "Submitting review",
+  DISCARD: "Discard",
+  /** What the panel says of the comments the member's pending review holds, which submitting publishes. */
+  pending: (count: number) =>
+    `${count} pending ${count === 1 ? "comment" : "comments"} will be published.`,
+  /** The Review press's name to a reader, with the pending comments it holds. */
+  openWith: (count: number) => `Review, ${count} pending ${count === 1 ? "comment" : "comments"}`,
 } as const;
 
+/** What Discard asks before it throws the member's pending review away. */
+const DISCARD_QUESTION: DialogQuestion = {
+  title: "Discard your pending review?",
+  body: "This deletes every pending comment you added to it. This can't be undone.",
+  verb: "Discard review",
+  running: "Discarding",
+};
+
 /** What the review may say, in the order GitHub's own review box offers it, and what each means. */
 const EVENT_OPTIONS = [
   {
@@ -91,12 +111,17 @@ function ReviewPanel({
   id,
   draft,
   writes,
+  pending,
+  onDiscard,
   onClose,
   onLeave,
 }: {
   id: string;
   draft: ReviewDraft;
   writes: PullRequestWrites;
+  pending: PendingReview;
+  /** Asks to throw the pending review away; offered only while one is held. */
+  onDiscard: () => void;
   onClose: () => void;
   onLeave: (left: EventTarget | null) => void;
 }): React.JSX.Element {
@@ -119,7 +144,12 @@ function ReviewPanel({
       onLeave={onLeave}
       onKeyDown={onKey}
     >
-      <p className="pull-request-review-lead">{REVIEW_WORDS.LEAD}</p>
+      <p className="pull-request-review-lead">
+        {REVIEW_WORDS.LEAD}
+        {pending == null || pending.comments === 0
+          ? null
+          : ` ${REVIEW_WORDS.pending(pending.comments)}`}
+      </p>
       <MarkdownField
         label={REVIEW_WORDS.BODY}
         placeholder={placeholderOf(draft.event)}
@@ -139,6 +169,16 @@ function ReviewPanel({
       />
       <PullRequestWriteNote writes={writes} className="pull-request-review-note" />
       <div className="pull-request-review-foot">
+        {pending == null ? null : (
+          <Button
+            variant={BUTTON_VARIANT.DANGER_OUTLINE}
+            icon={<Trash2Icon aria-hidden="true" />}
+            disabled={sending}
+            onClick={onDiscard}
+          >
+            {REVIEW_WORDS.DISCARD}
+          </Button>
+        )}
         <Button onClick={onClose}>{REVIEW_WORDS.CANCEL}</Button>
         <Button
           variant={BUTTON_VARIANT.PRIMARY}
@@ -158,7 +198,14 @@ function ReviewPanel({
  * written for as long as the tab stands, so a panel closed by a stray
  * click opens again on the same words.
  */
-export function PullRequestReview({ writes }: { writes: PullRequestWrites }): React.JSX.Element {
+export function PullRequestReview({
+  writes,
+  pending,
+}: {
+  writes: PullRequestWrites;
+  /** The member's own pending review, which the panel publishes or discards. */
+  pending: PendingReview;
+}): React.JSX.Element {
   const [open, setOpen] = useState(false);
   const [event, setEvent] = useState<ReviewEvent>(REVIEW_EVENT.COMMENT);
   const [body, setBody] = useState("");
@@ -169,7 +216,12 @@ export function PullRequestReview({ writes }: { writes: PullRequestWrites }): Re
   // Note that a press outside closes it too, as a menu's does, because the
   // field keeps the focus through a press on words nothing can focus, so no
   // blur says it was left; a review on its way holds it open all the same.
-  const sending = writes.pending !== undefined;
+  // Note that Discard sends its change once answered, and GitHub's answer is drawn in the panel, so the question holds the panel open as a review on its way does.
+  const discarding = useConfirmDialog({ subject: pending != null, surfaceOpen: open }, () => {
+    writes.write({ action: PULL_REQUEST_ACTION.DISCARD_REVIEW });
+    return Promise.resolve({ status: ACTION_RESULT_STATUS.ACCEPTED });
+  });
+  const sending = writes.pending !== undefined || discarding.stage !== CONFIRM_STAGE.RESTING;
   useEffect(() => {
     if (!open || sending) return undefined;
     const pressed = (event: PointerEvent) => {
@@ -200,9 +252,19 @@ export function PullRequestReview({ writes }: { writes: PullRequestWrites }): Re
         aria-haspopup="dialog"
         aria-expanded={open}
         aria-controls={open ? panelId : undefined}
+        label={
+          pending == null || pending.comments === 0
+            ? undefined
+            : REVIEW_WORDS.openWith(pending.comments)
+        }
         onClick={() => setOpen(!open)}
       >
         {REVIEW_WORDS.OPEN}
+        {pending == null || pending.comments === 0 ? null : (
+          <span className="pull-request-review-count" aria-hidden="true">
+            {pending.comments}
+          </span>
+        )}
       </Button>
       {open ? (
         <AnchoredPopover align={POPOVER_ALIGN.END} width={PANEL_WIDTH}>
@@ -210,6 +272,8 @@ export function PullRequestReview({ writes }: { writes: PullRequestWrites }): Re
             id={panelId}
             draft={{ event, body, setEvent, setBody, submit }}
             writes={writes}
+            pending={pending}
+            onDiscard={discarding.ask}
             onClose={close}
             onLeave={(left) => {
               // Note that a review on its way holds the panel open, because the
@@ -222,6 +286,7 @@ export function PullRequestReview({ writes }: { writes: PullRequestWrites }): Re
           />
         </AnchoredPopover>
       ) : null}
+      <ConfirmDialog confirm={discarding} question={DISCARD_QUESTION} />
     </div>
   );
 }
diff --git a/apps/desktop/src/renderer/tasks/pull-request-writes.tsx b/apps/desktop/src/renderer/tasks/pull-request-writes.tsx
index 2ab953f509..f9f6c23912 100644
--- a/apps/desktop/src/renderer/tasks/pull-request-writes.tsx
+++ b/apps/desktop/src/renderer/tasks/pull-request-writes.tsx
@@ -60,6 +60,8 @@ const ACTION_WORDS = {
   [PULL_REQUEST_ACTION.DISABLE_AUTO_MERGE]: "Disable auto-merge",
   [PULL_REQUEST_ACTION.DEQUEUE]: "Remove from queue",
   [PULL_REQUEST_ACTION.COMMENT]: "Comment",
+  [PULL_REQUEST_ACTION.ADD_REVIEW_COMMENT]: "Comment on lines",
+  [PULL_REQUEST_ACTION.DISCARD_REVIEW]: "Discard review",
 } as const satisfies Record<PullRequestAction, string>;
 
 /** The word for where the pull request stands, which the pill says. */
@@ -92,7 +94,7 @@ function failureWords(failure: CodingAgentCallFailure): string {
 }
 
 /** What the line under the bar says of the last change, where GitHub did not take it. */
-const WRITE_NOTE = {
+export const WRITE_NOTE = {
   SIGN_IN: "sign-in",
   WORDS: "words",
 } as const;
diff --git a/packages/service/src/agents/coding-agents-app.test.ts b/packages/service/src/agents/coding-agents-app.test.ts
index 90da706742..8dd5b017a0 100644
--- a/packages/service/src/agents/coding-agents-app.test.ts
+++ b/packages/service/src/agents/coding-agents-app.test.ts
@@ -666,9 +666,9 @@ const otherAccount = (token: string | null | undefined) =>
 const PUBLISHED = { branch: "luke/teammate-invitations", number: 12, headSha: "c0ffee1" } as const;
 
 /** The repository answering the published pull request's reads, its overview's among them: no checks, no comments, no reviews. */
-/** The same, the pull request a draft while `draft` says it is. */
+/** The same, the pull request a draft while `draft` says it is, its head the commit given, GitHub's short fixture one unless told. */
 const publishedPullRequestDrafted =
-  (draft: () => boolean): RepositoryScript =>
+  (draft: () => boolean, headSha: string = PUBLISHED.headSha): RepositoryScript =>
   (sent) => {
     const repository = `/repos/${RELAY.owner}/${RELAY.name}`;
     const pull = `${repository}/pulls/${PUBLISHED.number}`;
@@ -693,7 +693,7 @@ const publishedPullRequestDrafted =
           body: "Invitations expire.",
           body_html: "<p>Invitations expire.</p>",
           base: { ref: "main" },
-          head: { ref: PUBLISHED.branch, sha: PUBLISHED.headSha },
+          head: { ref: PUBLISHED.branch, sha: headSha },
           created_at: "2026-10-15T09:00:00Z",
           mergeable_state: "clean",
           user: null,
@@ -2136,13 +2136,7 @@ it.layer(getTestDB())("changing an agent's pull request", (it) => {
     "the changes name the head their files were read at, which a line comment is anchored to",
     () =>
       Effect.gen(function* () {
-        const headed: RepositoryScript = async (sent) => {
-          const answered = await publishedPullRequest(sent);
-          const pull = `/repos/${RELAY.owner}/${RELAY.name}/pulls/${PUBLISHED.number}`;
-          if (answered === undefined || new URL(sent.url).pathname !== pull) return answered;
-          const read: Record<string, unknown> = await answered.json();
-          return Response.json({ ...read, head: { ref: PUBLISHED.branch, sha: LINE_HEAD } });
-        };
+        const headed = publishedPullRequestDrafted(() => false, LINE_HEAD);
         const { owner, agent, ask } = yield* published({ repository: headed });
 
         const changes = readAnswer(
diff --git a/packages/service/src/github/pull-request-writes.ts b/packages/service/src/github/pull-request-writes.ts
index 796f8bc165..ce58e77668 100644
--- a/packages/service/src/github/pull-request-writes.ts
+++ b/packages/service/src/github/pull-request-writes.ts
@@ -481,7 +481,7 @@ const REVIEW_THREAD_MUTATION = `mutation($review: ID!, ${THREAD_VARIABLES}) {
 }`;
 
 /** A line comment's place and words as its document's variables: one line where no start is named. */
-function threadVariables(comment: LineComment): Readonly<Record<string, string | number>> {
+function threadVariables(comment: LineComment) {
   return {
     path: comment.path,
     body: comment.body,

From 7abfe530596ee3674d17f0f3c76268563d38ebd7 Mon Sep 17 00:00:00 2001
From: Dean Stratakos <29683763+dastratakos@users.noreply.github.com>
Date: Sun, 18 Oct 2026 18:05:49 +0000
Subject: [PATCH 6/7] fix(service,desktop): start a review with its first
 comment, refuse one held on another commit, and let Discard wait on GitHub

A review a line comment starts is now made with that comment in one
`addPullRequestReview`, so a comment GitHub refuses leaves no empty
pending review behind. A comment for a review held pending on a commit
other than the one the diff was read at is refused in words saying so,
rather than given lines counted on another commit. Discard's question
stands busy until GitHub answers and says its refusal in GitHub's words,
`usePullRequestWrites.write` answering how the change went. The Refresh
changes test asserts the files as drawn again, not how often they were
read.

Co-authored-by: luke-agent[bot] <339870089+luke-agent[bot]@users.noreply.github.com>
---
 .../tasks/agent-pull-request-tab.test.ts      | 53 ++++++++--
 .../renderer/tasks/pull-request-review.tsx    | 18 ++--
 .../renderer/tasks/pull-request-writes.tsx    | 23 ++++-
 .../src/agents/coding-agents-app.test.ts      | 96 +++++++++++++------
 .../service/src/github/pull-request-writes.ts | 56 +++++++----
 5 files changed, 182 insertions(+), 64 deletions(-)

diff --git a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
index 49bc42a1c4..628c7184db 100644
--- a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
+++ b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
@@ -2696,8 +2696,11 @@ const INVITE_FILE = {
   patch: thread().diffHunk.replace("@@ -8,6 +8,7 @@", "@@ -8,5 +8,6 @@"),
 };
 
-/** The tab over that one file, read at `READ_HEAD`, its conversation holding the member's pending review as given, and how many times the changes were read. */
-async function drawCommentable(pendingReview?: { readonly comments: number } | null) {
+/** The tab over that one file, read at `READ_HEAD`, its conversation holding the member's pending review as given; a read of the changes after the first answers `reread` in its place where one is given. */
+async function drawCommentable(
+  pendingReview?: { readonly comments: number } | null,
+  reread: typeof INVITE_FILE = INVITE_FILE,
+) {
   const read = { changes: 0 };
   const tab = await draw(
     controlAnswering(
@@ -2714,14 +2717,19 @@ async function drawCommentable(pendingReview?: { readonly comments: number } | n
       () => {
         read.changes += 1;
         return Promise.resolve({
-          pullRequest: { url: PAGE, headSha: READ_HEAD, truncated: false, files: [INVITE_FILE] },
+          pullRequest: {
+            url: PAGE,
+            headSha: READ_HEAD,
+            truncated: false,
+            files: [read.changes === 1 ? INVITE_FILE : reread],
+          },
         });
       },
     ),
   );
   await act(async () => option(tab, "Files changed").click());
   await settle();
-  return { tab, read };
+  return { tab };
 }
 
 /** Presses the gutter's + on the lines given of the file, as the diff bundle tells the view, and the comment it opened. */
@@ -2862,12 +2870,15 @@ test("a member holding a pending review adds a comment to it and nothing else, a
   );
 });
 
-test("a comment GitHub refuses says so under it in GitHub's own words, its words kept, beside Refresh changes, which reads the files again", async () => {
+test("a comment GitHub refuses says so under it in GitHub's own words, its words kept, beside Refresh changes, which draws the files as read again", async () => {
   changeAnswer = {
     outcome: PULL_REQUEST_WRITE_OUTCOME.REFUSED,
     words: "Pull request review thread line must be part of the diff",
   };
-  const { read } = await drawCommentable();
+  await drawCommentable(undefined, { ...INVITE_FILE, additions: 5 });
+  const lines = () =>
+    lists.at(-1)?.renderHeader(INVITE_FILE.path).querySelector(".agent-published-added")
+      ?.textContent;
   const comment = await pickLines({
     start: 9,
     side: DIFF_SELECTION_SIDE.ADDITIONS,
@@ -2884,8 +2895,34 @@ test("a comment GitHub refuses says so under it in GitHub's own words, its words
     "GitHub said: Pull request review thread line must be part of the diff",
   );
   assert.equal(comment.querySelector("textarea")?.value, "Here.");
-  const before = read.changes;
+  assert.match(lines() ?? "", /\+2/u);
   act(() => commentOffer(comment, "Refresh changes").click());
   await settle();
-  assert.equal(read.changes, before + 1);
+  assert.match(lines() ?? "", /\+5/u, "the files are drawn as read again");
+});
+
+test("Discard's question stands busy until GitHub answers, and says GitHub's refusal in its words", async () => {
+  const held = Promise.withResolvers<void>();
+  changeHeld = held.promise;
+  changeAnswer = { outcome: PULL_REQUEST_WRITE_OUTCOME.REFUSED, words: "Review is not pending" };
+  const { tab } = await drawCommentable({ comments: 1 });
+  act(() =>
+    (
+      tab.querySelector<HTMLButtonElement>('[aria-label="Review, 1 pending comment"]') ??
+      assert.fail("Review counts the pending comment")
+    ).click(),
+  );
+  const panel =
+    tab.querySelector<HTMLElement>('[role="dialog"]') ?? assert.fail("Review opens its panel");
+  act(() => commentOffer(panel, "Discard").click());
+  const question = () =>
+    document.querySelector<HTMLElement>('[role="alertdialog"]') ??
+    assert.fail("Discard asks first");
+  act(() => commentOffer(question(), "Discard review").click());
+  await settle();
+
+  assert.equal(question().getAttribute("aria-busy"), "true", "the question waits on GitHub");
+  held.resolve();
+  await settle();
+  assert.match(question().textContent ?? "", /GitHub said: Review is not pending/u);
 });
diff --git a/apps/desktop/src/renderer/tasks/pull-request-review.tsx b/apps/desktop/src/renderer/tasks/pull-request-review.tsx
index d8996ef405..71a5472e3e 100644
--- a/apps/desktop/src/renderer/tasks/pull-request-review.tsx
+++ b/apps/desktop/src/renderer/tasks/pull-request-review.tsx
@@ -15,7 +15,7 @@ import {
   useConfirmDialog,
 } from "@luke/ui";
 import { CONFIRM_STAGE } from "@luke/ui/confirm-state";
-import { ACTION_RESULT_STATUS } from "@luke/wire";
+import { ACTION_RESULT_STATUS, type ActionResult } from "@luke/wire";
 import { MessageSquarePlusIcon, Trash2Icon } from "lucide-react";
 import { useEffect, useId, useRef, useState } from "react";
 import { PopoverPanel } from "../popover-panel";
@@ -216,11 +216,17 @@ export function PullRequestReview({
   // Note that a press outside closes it too, as a menu's does, because the
   // field keeps the focus through a press on words nothing can focus, so no
   // blur says it was left; a review on its way holds it open all the same.
-  // Note that Discard sends its change once answered, and GitHub's answer is drawn in the panel, so the question holds the panel open as a review on its way does.
-  const discarding = useConfirmDialog({ subject: pending != null, surfaceOpen: open }, () => {
-    writes.write({ action: PULL_REQUEST_ACTION.DISCARD_REVIEW });
-    return Promise.resolve({ status: ACTION_RESULT_STATUS.ACCEPTED });
-  });
+  // Note that the question stands, busy, until GitHub answers the discard, says its refusal in GitHub's words, and holds the panel open meanwhile as a review on its way does.
+  const discarding = useConfirmDialog({ subject: pending != null, surfaceOpen: open }, () =>
+    writes
+      .write({ action: PULL_REQUEST_ACTION.DISCARD_REVIEW })
+      .then(
+        (outcome): ActionResult =>
+          outcome.done
+            ? { status: ACTION_RESULT_STATUS.ACCEPTED }
+            : { status: ACTION_RESULT_STATUS.REJECTED, reason: outcome.words },
+      ),
+  );
   const sending = writes.pending !== undefined || discarding.stage !== CONFIRM_STAGE.RESTING;
   useEffect(() => {
     if (!open || sending) return undefined;
diff --git a/apps/desktop/src/renderer/tasks/pull-request-writes.tsx b/apps/desktop/src/renderer/tasks/pull-request-writes.tsx
index f9f6c23912..4f01ab048c 100644
--- a/apps/desktop/src/renderer/tasks/pull-request-writes.tsx
+++ b/apps/desktop/src/renderer/tasks/pull-request-writes.tsx
@@ -103,6 +103,21 @@ type WriteNote =
   | { readonly kind: typeof WRITE_NOTE.SIGN_IN }
   | { readonly kind: typeof WRITE_NOTE.WORDS; readonly words: string };
 
+/** How a change went, for a press that waits on it, such as a question's answer: made, or not, in the words the line says why. */
+type WriteOutcome = { readonly done: true } | { readonly done: false; readonly words: string };
+
+/** What a press sent while another change is out is told: it was not sent. */
+const NOT_SENT: WriteOutcome = { done: false, words: "Another change is on its way to GitHub." };
+
+/** How an answer went, in the words its line says where GitHub did not make the change. */
+function outcomeOf(note: WriteNote | undefined): WriteOutcome {
+  if (note === undefined) return { done: true };
+  return {
+    done: false,
+    words: note.kind === WRITE_NOTE.SIGN_IN ? WRITE_WORDS.SIGN_IN : note.words,
+  };
+}
+
 /** The tab's changes: the one out, if any, what the last one left to say, and the presses. */
 export interface PullRequestWrites {
   /** The change out now; none while nothing is. */
@@ -113,7 +128,7 @@ export interface PullRequestWrites {
    * sent it can let go of what it held, and what it answers settles once
    * GitHub answered and what it said is drawn, as a merge's question waits.
    */
-  readonly write: (request: PullRequestActionRequest, onDone?: () => void) => Promise<void>;
+  readonly write: (request: PullRequestActionRequest, onDone?: () => void) => Promise<WriteOutcome>;
   readonly dismiss: () => void;
 }
 
@@ -144,7 +159,7 @@ export function usePullRequestWrites(agentId: string, onWritten: () => void): Pu
   const out = useRef(false);
   const write = useCallback(
     (request: PullRequestActionRequest, onDone?: () => void) => {
-      if (out.current) return Promise.resolve();
+      if (out.current) return Promise.resolve(NOT_SENT);
       out.current = true;
       setPending(request.action);
       setNote(undefined);
@@ -157,12 +172,14 @@ export function usePullRequestWrites(agentId: string, onWritten: () => void): Pu
         .then((answer) => {
           out.current = false;
           setPending(undefined);
-          setNote(noteOf(answer));
+          const note = noteOf(answer);
+          setNote(note);
           if (!("failure" in answer) && answer.outcome === PULL_REQUEST_WRITE_OUTCOME.DONE) {
             onDone?.();
           }
           // Note that a refusal may still have moved the pull request, so every answer from GitHub reads again.
           if (!("failure" in answer)) onWritten();
+          return outcomeOf(note);
         });
     },
     [act, agentId, onWritten],
diff --git a/packages/service/src/agents/coding-agents-app.test.ts b/packages/service/src/agents/coding-agents-app.test.ts
index 8dd5b017a0..1ffbbd13a9 100644
--- a/packages/service/src/agents/coding-agents-app.test.ts
+++ b/packages/service/src/agents/coding-agents-app.test.ts
@@ -1377,13 +1377,20 @@ function reviewAs(
   });
 }
 
+/** One of the pull request's pending reviews as GitHub answers it: its id, whether the asker wrote it, and the commit it was started on where told. */
+interface PendingNode {
+  readonly id: string;
+  readonly viewerDidAuthor: boolean;
+  readonly commit?: { readonly oid: string };
+}
+
 /**
  * GitHub answering a review's calls: the pull request's id, the pending
  * reviews given for its read of them, and each mutation as `mutation`
  * says, an empty answer by default.
  */
 function reviewsAnswering(
-  pending: readonly { readonly id: string; readonly viewerDidAuthor: boolean }[],
+  pending: readonly PendingNode[],
   mutation: (call: GraphqlCall) => Response = () => Response.json({ data: {} }),
 ): (call: GraphqlCall) => Response {
   return (call) => {
@@ -1450,20 +1457,9 @@ function lineCommentAs(
   });
 }
 
-/** GitHub answering a line comment's and a discard's calls: the member's pending reviews as given, a started review as `PRR_started`, and an empty answer to every other mutation. */
-function linesAnswering(
-  pending: readonly { readonly id: string; readonly viewerDidAuthor: boolean }[],
-): (call: GraphqlCall) => Response {
-  return (call) => {
-    if (
-      call.query.includes("addPullRequestReview(input: { pullRequestId: $id, commitOID: $commit })")
-    ) {
-      return Response.json({
-        data: { addPullRequestReview: { pullRequestReview: { id: "PRR_started" } } },
-      });
-    }
-    return reviewsAnswering(pending)(call);
-  };
+/** GitHub answering a line comment's and a discard's calls: the member's pending reviews as given, and an empty answer to every mutation. */
+function linesAnswering(pending: readonly PendingNode[]): (call: GraphqlCall) => Response {
+  return reviewsAnswering(pending);
 }
 
 it.layer(getTestDB())("changing an agent's pull request", (it) => {
@@ -1999,7 +1995,7 @@ it.layer(getTestDB())("changing an agent's pull request", (it) => {
         const holding = yield* published({
           answer: linesAnswering([
             { id: "PRR_someone_else", viewerDidAuthor: false },
-            { id: "PRR_member_pending", viewerDidAuthor: true },
+            { id: "PRR_member_pending", viewerDidAuthor: true, commit: { oid: LINE_HEAD } },
           ]),
         });
         const joined = yield* holding.ask(
@@ -2009,25 +2005,71 @@ it.layer(getTestDB())("changing an agent's pull request", (it) => {
         for (const answered of [started, joined]) {
           assert.deepEqual(answered, { status: HOSTED_HTTP_STATUS.OK, body: { outcome: "done" } });
         }
-        const thread = (calls: readonly GraphqlCall[]) =>
+        const mutations = (calls: readonly GraphqlCall[]) =>
           calls
             .filter((call) => call.query.includes("mutation"))
-            .map((call) => [mutationName(call.query), call.variables.id ?? call.variables.review]);
-        assert.deepEqual(thread(fresh.calls), [
-          ["addPullRequestReview", PULL_REQUEST_NODE_ID],
-          ["addPullRequestReviewThread", "PRR_started"],
+            .map((call) => [mutationName(call.query), call.variables]);
+        assert.deepEqual(mutations(fresh.calls), [
+          [
+            "addPullRequestReview",
+            {
+              id: PULL_REQUEST_NODE_ID,
+              commit: LINE_HEAD,
+              path: "src/invite.ts",
+              body: "Rename this.",
+              line: 12,
+              side: "LEFT",
+            },
+          ],
         ]);
-        assert.equal(
-          fresh.calls.find((call) => call.query.includes("addPullRequestReviewThread"))?.variables
-            .side,
-          "LEFT",
+        assert.doesNotMatch(
+          fresh.calls.find((call) => call.query.includes("mutation"))?.query ?? "",
+          /event:/u,
+          "the review is started pending, its first thread with it",
         );
-        assert.deepEqual(thread(holding.calls), [
-          ["addPullRequestReviewThread", "PRR_member_pending"],
+        assert.deepEqual(mutations(holding.calls), [
+          [
+            "addPullRequestReviewThread",
+            {
+              review: "PRR_member_pending",
+              path: "src/invite.ts",
+              body: "Rename this.",
+              line: 12,
+              side: "RIGHT",
+            },
+          ],
         ]);
       }),
   );
 
+  it.effect(
+    "a comment for a review held pending on another commit is refused in words saying so, its lines never sent to that review",
+    () =>
+      Effect.gen(function* () {
+        const { other, agent, calls, ask } = yield* published({
+          answer: linesAnswering([
+            {
+              id: "PRR_member_pending",
+              viewerDidAuthor: true,
+              commit: { oid: "0ld0ld0ld0ld0ld0ld0ld0ld0ld0ld0ld0ld0ld0" },
+            },
+          ]),
+        });
+
+        const answered = yield* ask(lineCommentAs(other, agent.id, { mode: "review" }));
+
+        assert.deepEqual(answered, {
+          status: HOSTED_HTTP_STATUS.OK,
+          body: {
+            outcome: "refused",
+            words:
+              "Your pending review was started on another commit. Submit or discard it, then refresh changes to comment on these lines.",
+          },
+        });
+        assert.ok(calls.every((call) => !call.query.includes("mutation")));
+      }),
+  );
+
   it.effect(
     "Discard throws away the member's own pending review and nobody else's, and is refused in words where they hold none",
     () =>
diff --git a/packages/service/src/github/pull-request-writes.ts b/packages/service/src/github/pull-request-writes.ts
index ce58e77668..5dea82383e 100644
--- a/packages/service/src/github/pull-request-writes.ts
+++ b/packages/service/src/github/pull-request-writes.ts
@@ -195,7 +195,7 @@ const PENDING_REVIEWS_READ = 10;
 const PENDING_REVIEW_QUERY = `query($id: ID!) {
   node(id: $id) {
     ... on PullRequest {
-      reviews(states: PENDING, first: ${PENDING_REVIEWS_READ}) { nodes { id viewerDidAuthor } }
+      reviews(states: PENDING, first: ${PENDING_REVIEWS_READ}) { nodes { id viewerDidAuthor commit { oid } } }
     }
   }
 }`;
@@ -203,7 +203,13 @@ const PENDING_REVIEW_QUERY = `query($id: ID!) {
 const PendingReviewsSchema = Schema.Struct({
   node: Schema.Struct({
     reviews: Schema.Struct({
-      nodes: Schema.Array(Schema.Struct({ id: Schema.String, viewerDidAuthor: Schema.Boolean })),
+      nodes: Schema.Array(
+        Schema.Struct({
+          id: Schema.String,
+          viewerDidAuthor: Schema.Boolean,
+          commit: Schema.optionalKey(Schema.NullOr(Schema.Struct({ oid: Schema.String }))),
+        }),
+      ),
     }),
   }),
 });
@@ -468,14 +474,12 @@ const SINGLE_COMMENT_MUTATION = `mutation($id: ID!, $commit: GitObjectID!, ${THR
   }
 }`;
 
-const START_REVIEW_MUTATION = `mutation($id: ID!, $commit: GitObjectID!) {
-  addPullRequestReview(input: { pullRequestId: $id, commitOID: $commit }) { pullRequestReview { id } }
+const START_REVIEW_MUTATION = `mutation($id: ID!, $commit: GitObjectID!, ${THREAD_VARIABLES}) {
+  addPullRequestReview(input: { pullRequestId: $id, commitOID: $commit, threads: [{ ${THREAD_FIELDS} }] }) {
+    pullRequestReview { id }
+  }
 }`;
 
-const StartedReviewSchema = Schema.Struct({
-  addPullRequestReview: Schema.Struct({ pullRequestReview: Schema.Struct({ id: Schema.String }) }),
-});
-
 const REVIEW_THREAD_MUTATION = `mutation($review: ID!, ${THREAD_VARIABLES}) {
   addPullRequestReviewThread(input: { pullRequestReviewId: $review, ${THREAD_FIELDS} }) { thread { id } }
 }`;
@@ -494,15 +498,22 @@ function threadVariables(comment: LineComment) {
   };
 }
 
+/** What the member is told where the review they hold pending was started on a commit other than the one their diff was read at, whose lines may not be these. */
+const PENDING_ON_OTHER_COMMIT =
+  "Your pending review was started on another commit. Submit or discard it, then refresh changes to comment on these lines.";
+
 /**
  * A comment on lines of a changed file, on the member's token, as GitHub's
  * own line comment offers it: published at once as a review of its own
  * (`single`), as "Add single comment" does; or added to the member's own
- * pending review (`review`), one started on the head their diff was read
- * at where they hold none, which is the review the Review panel submits
- * (`submitPullRequestReview`). GitHub's rules, a line outside the diff, a
- * range across hunks, a head no longer the pull request's, are its refusal
- * in its words.
+ * pending review (`review`), or, where they hold none, one started with it
+ * on the head their diff was read at, in the one call, so a refused comment
+ * never leaves an empty review behind; that review is the one the Review
+ * panel submits (`submitPullRequestReview`). A pending review started on
+ * another commit is refused in words saying so rather than given lines
+ * counted on this one. GitHub's rules, a line outside the diff, a range
+ * across hunks, a head no longer the pull request's, are its refusal in
+ * its words.
  */
 export const addLineComment = /* @__PURE__ */ Effect.fn("web/addLineComment")(function* (
   token: Redacted.Redacted,
@@ -520,15 +531,20 @@ export const addLineComment = /* @__PURE__ */ Effect.fn("web/addLineComment")(fu
     return;
   }
   const own = yield* ownPendingReview(token, pullRequestId);
-  const review =
-    own?.id ??
-    (yield* githubWrite(
+  if (own === undefined) {
+    yield* githubWrite(
       token,
       START_REVIEW_MUTATION,
-      { id: pullRequestId, commit: comment.headSha },
-      StartedReviewSchema,
-    )).addPullRequestReview.pullRequestReview.id;
-  yield* githubWrite(token, REVIEW_THREAD_MUTATION, { review, ...thread }, Schema.Unknown);
+      { id: pullRequestId, commit: comment.headSha, ...thread },
+      Schema.Unknown,
+    );
+    return;
+  }
+  const started = own.commit?.oid;
+  if (started !== undefined && started !== comment.headSha) {
+    return yield* refusalOf([PENDING_ON_OTHER_COMMIT]);
+  }
+  yield* githubWrite(token, REVIEW_THREAD_MUTATION, { review: own.id, ...thread }, Schema.Unknown);
 });
 
 const DISCARD_REVIEW_MUTATION = `mutation($id: ID!) {

From be355959a01c0c479d17458b0794aaa4bcc8a951 Mon Sep 17 00:00:00 2001
From: Dean Stratakos <29683763+dastratakos@users.noreply.github.com>
Date: Sun, 18 Oct 2026 19:11:03 +0000
Subject: [PATCH 7/7] fix(desktop): read the comment box's refusal as main now
 draws every one

#3568 draws a write's refusal as `ErrorState`, so the comment box's own
`.failure-note-words` rule draws nothing and its test read no words. The
rule goes, and the test reads the refusal by its alert, as the thread's
does.

Co-authored-by: luke-agent[bot] <339870089+luke-agent[bot]@users.noreply.github.com>
---
 apps/desktop/src/renderer/styles/tasks.css         | 14 ++------------
 .../renderer/tasks/agent-pull-request-tab.test.ts  |  2 +-
 2 files changed, 3 insertions(+), 13 deletions(-)

diff --git a/apps/desktop/src/renderer/styles/tasks.css b/apps/desktop/src/renderer/styles/tasks.css
index 6b1768e6fa..244bb39345 100644
--- a/apps/desktop/src/renderer/styles/tasks.css
+++ b/apps/desktop/src/renderer/styles/tasks.css
@@ -2619,24 +2619,14 @@
 
 /* The comment box at the foot of the Conversation
    (`pull-request-comment-box.tsx`): the words with their preview, GitHub's
-   refusal under them, and Comment at the row's end. */
+   refusal under them, drawn as every refusal is (`ErrorState`), and
+   Comment at the row's end. */
 .pull-request-comment-box {
   display: flex;
   flex-direction: column;
   gap: var(--luke-space-8);
 }
 
-.pull-request-comment-note {
-  margin: 0;
-  color: var(--luke-color-text-muted);
-  font-size: var(--luke-type-caption-size);
-}
-
-.pull-request-comment-note .failure-note-words {
-  flex: 1 1 auto;
-  min-width: 0;
-}
-
 .pull-request-comment-foot {
   display: flex;
   justify-content: flex-end;
diff --git a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
index 96f8e007dc..1b2d955b81 100644
--- a/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
+++ b/apps/desktop/src/renderer/tasks/agent-pull-request-tab.test.ts
@@ -2868,7 +2868,7 @@ test("a comment GitHub refuses says so under the box in GitHub's own words, its
   await settle();
 
   assert.equal(
-    tab.querySelector(".pull-request-comment-note .failure-note-words")?.textContent,
+    tab.querySelector(".pull-request-comment-note [role='alert']")?.textContent,
     "GitHub said: Conversation is locked to collaborators",
   );
   assert.equal(