git-reviewer 2.15.0 → 2.16.0

package/lib/store.js

@@ -2,8 +2,10 @@
 
 const fs = require('fs').promises;
 const path = require('path');
+const crypto = require('crypto');
 
 const { commentsFilename, legacyCommentsFilename, canonicalRepoPath } = require('./review');
+const { withKeys } = require('./comments');
 
 /**
  * Reading a repository's saved comments, whatever name they were written under.
@@ -74,10 +76,15 @@ async function readJson(file) {
  *
  * @param {string} reviewsDir
  * @param {string} repoPath
- * @returns {Promise<{comments: object[], mode: string|null, range: object|null, untracked?: boolean, adopted: boolean}>}
+ * @returns {Promise<{comments: object[], mode: string|null, range: object|null, untracked?: boolean, adopted: boolean, lastUpdated: string|null}>}
  *   `mode` is null for a file written before it was recorded -- there is
  *   nothing on disk that says what was compared, and guessing would be
- *   worse than admitting it.
+ *   worse than admitting it. `lastUpdated` is null when the file carries
+ *   no stamp (or there is no file yet): it is the version token a caller
+ *   sends back on save so the server can tell a current writer from a
+ *   stale one (#107). Every comment and follow-up comes back with a `key`;
+ *   one saved before keys existed gets the key derived from its content (see
+ *   `withKeys`), the same on every read.
  * @throws {ReviewOwnershipError} when the current file names another repository
  */
 async function readSavedComments(reviewsDir, repoPath) {
@@ -91,18 +98,19 @@ async function readSavedComments(reviewsDir, repoPath) {
       throw new ReviewOwnershipError(repoPath, saved.repoPath);
     }
     return {
-      comments: saved.comments ?? [], mode: saved.mode ?? null, range: saved.range ?? null,
+      comments: withKeys(saved.comments ?? []), mode: saved.mode ?? null, range: saved.range ?? null,
       ...(saved.mode === 'working' && saved.untracked === false ? { untracked: false } : {}),
-      adopted: false
+      adopted: false,
+      lastUpdated: saved.lastUpdated ?? null
     };
   }
 
   const legacyName = legacyCommentsFilename(repoPath);
-  if (legacyName === commentsFilename(repoPath)) return { comments: [], mode: null, range: null, adopted: false };
+  if (legacyName === commentsFilename(repoPath)) return { comments: [], mode: null, range: null, adopted: false, lastUpdated: null };
 
   const legacy = await readJson(path.join(reviewsDir, legacyName));
   if (legacy === null || !belongsTo(legacy.repoPath, repoPath)) {
-    return { comments: [], mode: null, range: null, adopted: false };
+    return { comments: [], mode: null, range: null, adopted: false, lastUpdated: null };
   }
 
   // Move it under the new name so the next read is a plain hit and the old
@@ -115,10 +123,277 @@ async function readSavedComments(reviewsDir, repoPath) {
   }
 
   return {
-    comments: legacy.comments ?? [], mode: legacy.mode ?? null, range: legacy.range ?? null,
+    comments: withKeys(legacy.comments ?? []), mode: legacy.mode ?? null, range: legacy.range ?? null,
     ...(legacy.mode === 'working' && legacy.untracked === false ? { untracked: false } : {}),
-    adopted: true
+    adopted: true,
+    lastUpdated: legacy.lastUpdated ?? null
   };
 }
 
-module.exports = { readSavedComments, ReviewOwnershipError, belongsTo };
+/**
+ * The `lastUpdated` stamp for a save that follows `previous`.
+ *
+ * Stamps are the version token for conditional saves (#107), so a new stamp
+ * must differ from the one it replaces even when two saves land inside the
+ * same millisecond -- otherwise a stale tab would look current by accident.
+ *
+ * @param {string|null} previous stamp currently on disk, if any
+ * @returns {string} ISO 8601 stamp strictly after `previous`
+ */
+function nextLastUpdated(previous) {
+  const parsed = previous ? Date.parse(previous) : NaN;
+  const stamp = Number.isNaN(parsed) ? Date.now() : Math.max(Date.now(), parsed + 1);
+  return new Date(stamp).toISOString();
+}
+
+// A lock older than this belongs to a writer that died holding it. Reading
+// and writing one small JSON file takes milliseconds; ten seconds is not a
+// writer that is merely slow. A lock whose writer is provably gone is not
+// waited on at all.
+const LOCK_STALE_MS = 10000;
+const LOCK_RETRY_MS = 15;
+const LOCK_TIMEOUT_MS = 5000;
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+/**
+ * Whether a process is running.
+ *
+ * @param {number} pid
+ * @returns {boolean}
+ */
+function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM: it exists, it just is not ours to signal.
+    return error.code === 'EPERM';
+  }
+}
+
+/**
+ * Whether creating a lock failed only because somebody else holds it.
+ *
+ * EEXIST everywhere. On Windows, also EPERM and EACCES: a file another
+ * process has just deleted lingers as "delete pending" while anyone still
+ * has it open, and creating one by the same name is refused until it is
+ * gone -- the lock is being released, not withheld. CI caught it: two
+ * writers in separate processes, and one of them died of EPERM.
+ *
+ * @param {NodeJS.ErrnoException} error
+ */
+function lockIsBusy(error) {
+  if (error.code === 'EEXIST') return true;
+  return process.platform === 'win32' && (error.code === 'EPERM' || error.code === 'EACCES');
+}
+
+/**
+ * Whether a lock has been abandoned: the process that wrote it has gone, or
+ * it has been held far longer than any write takes.
+ *
+ * @param {string} lock
+ * @returns {Promise<boolean>}
+ */
+async function isAbandoned(lock) {
+  const [content, stat] = await Promise.all([
+    fs.readFile(lock, 'utf-8').catch(() => null),
+    fs.stat(lock).catch(() => null)
+  ]);
+  if (content === null || !stat) return false; // released meanwhile: just try again
+  const owner = Number.parseInt(content, 10);
+  if (Number.isInteger(owner) && owner > 0 && !isAlive(owner)) return true;
+  return Date.now() - stat.mtimeMs > LOCK_STALE_MS;
+}
+
+/**
+ * Remove a lock whose writer died holding it, and say whether it was removed.
+ *
+ * Two waiters can both find the same lock abandoned. If each simply removed
+ * it, the second would remove the lock the first had just taken, and both
+ * would write at once -- the lost reply the lock exists to prevent. So
+ * breaking a lock is done under a lock of its own, and the one holding it
+ * looks again before removing anything. Nothing but a breaker removes a lock
+ * that is not its own, and there is one breaker at a time.
+ *
+ * @param {string} lock
+ * @returns {Promise<boolean>}
+ */
+async function breakAbandonedLock(lock) {
+  if (!(await isAbandoned(lock))) return false;
+
+  const breaker = `${lock}.break`;
+  try {
+    await (await fs.open(breaker, 'wx')).close();
+  } catch (error) {
+    if (!lockIsBusy(error)) throw error;
+    // Somebody else is breaking it. One who died doing so is cleared by age.
+    const stat = await fs.stat(breaker).catch(() => null);
+    if (stat && Date.now() - stat.mtimeMs > LOCK_STALE_MS) await fs.rm(breaker, { force: true });
+    return false;
+  }
+
+  try {
+    if (!(await isAbandoned(lock))) return false;
+    await fs.rm(lock, { force: true });
+    return true;
+  } finally {
+    await fs.rm(breaker, { force: true });
+  }
+}
+
+/**
+ * Run `task` holding the lock on `file`, against every process on the machine.
+ *
+ * The page is no longer the only writer. An agent answering in a thread
+ * writes the same file from another process -- `reviewer channel`, run by
+ * Claude Code -- and a read-modify-write from each, interleaved, loses one of
+ * them. The lock is a sibling file created with `wx`, which the operating
+ * system creates atomically or refuses, on every platform Node runs on, and
+ * which holds the writer's pid so a lock left by a process that died can be
+ * recognised as such.
+ *
+ * @template T
+ * @param {string} file
+ * @param {() => Promise<T>} task
+ * @returns {Promise<T>}
+ */
+async function withFileLock(file, task) {
+  const lock = `${file}.lock`;
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+
+  for (;;) {
+    try {
+      const handle = await fs.open(lock, 'wx');
+      try {
+        await handle.writeFile(`${process.pid}\n`);
+      } finally {
+        await handle.close();
+      }
+      break;
+    } catch (error) {
+      if (!lockIsBusy(error)) throw error;
+      if (error.code === 'EEXIST' && await breakAbandonedLock(lock)) continue;
+      if (Date.now() > deadline) {
+        if (error.code !== 'EEXIST') throw error;
+        throw new Error(`Timed out waiting for ${path.basename(lock)}; if no reviewer is running, delete it.`);
+      }
+      await sleep(LOCK_RETRY_MS);
+    }
+  }
+
+  try {
+    return await task();
+  } finally {
+    await fs.rm(lock, { force: true });
+  }
+}
+
+/**
+ * Replace `file` in one step, so no reader ever sees half of it.
+ *
+ * A reader in another process -- an agent watching the review -- would
+ * otherwise be able to catch the file truncated mid-write and parse nothing.
+ * Windows refuses to rename over a file another process has open for a
+ * moment, so that is retried briefly rather than failing the save.
+ *
+ * @param {string} file
+ * @param {string} content
+ */
+async function writeFileAtomic(file, content) {
+  const temporary = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+  await fs.writeFile(temporary, content);
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await fs.rename(temporary, file);
+      return;
+    } catch (error) {
+      if (attempt < 20 && ['EPERM', 'EACCES', 'EBUSY'].includes(error.code)) {
+        await sleep(10);
+        continue;
+      }
+      await fs.rm(temporary, { force: true });
+      throw error;
+    }
+  }
+}
+
+// Writes from this process to one file go one at a time, so they queue here
+// instead of polling for the lock against each other.
+/** @type {Map<string, Promise<void>>} */
+const queues = new Map();
+
+function serialize(file, task) {
+  const previous = queues.get(file) ?? Promise.resolve();
+  const run = previous.then(task, task);
+  const tail = run.then(() => {}, () => {});
+  queues.set(file, tail);
+  tail.then(() => {
+    if (queues.get(file) === tail) queues.delete(file);
+  });
+  return run;
+}
+
+/**
+ * @typedef {object} SavedReview
+ * @property {import('./comments').Comment[]} comments keyed
+ * @property {string|null} mode
+ * @property {object|null} range
+ * @property {boolean} [untracked]
+ * @property {string|null} lastUpdated
+ */
+
+/**
+ * Change a repository's saved comments, safely against every other writer.
+ *
+ * Takes the lock, reads what is on disk now, and hands it to `update`, which
+ * returns the comments to write -- or null to write nothing, which is how a
+ * conditional save turns itself down. What it returns is written in one step
+ * with a `lastUpdated` strictly after the one it replaced. The scope fields
+ * (`mode`, `range`, `untracked`) are kept from disk unless `update` supplies
+ * them: a reply in a thread does not change what the review is of.
+ *
+ * @param {string} reviewsDir
+ * @param {string} repoPath
+ * @param {(current: SavedReview) => ({comments: object[], scope?: {mode: string|null, range: object|null, untracked?: boolean}}|null|Promise<object|null>)} update
+ * @returns {Promise<{written: boolean, comments: object[], lastUpdated: string|null}>}
+ */
+async function updateSavedComments(reviewsDir, repoPath, update) {
+  const file = path.join(reviewsDir, commentsFilename(repoPath));
+
+  return serialize(file, async () => {
+    await fs.mkdir(reviewsDir, { recursive: true });
+
+    return withFileLock(file, async () => {
+      const current = await readSavedComments(reviewsDir, repoPath);
+      const change = await update(current);
+      if (!change) return { written: false, comments: current.comments, lastUpdated: current.lastUpdated };
+
+      const scope = change.scope ?? current;
+      const lastUpdated = nextLastUpdated(current.lastUpdated ?? null);
+      const data = {
+        repoPath,
+        lastUpdated,
+        mode: scope.mode ?? null,
+        range: scope.range ?? null,
+        ...(scope.mode === 'working' && scope.untracked === false ? { untracked: false } : {}),
+        comments: change.comments
+      };
+      await writeFileAtomic(file, `${JSON.stringify(data, null, 2)}\n`);
+
+      return { written: true, comments: change.comments, lastUpdated };
+    });
+  });
+}
+
+module.exports = {
+  readSavedComments,
+  updateSavedComments,
+  nextLastUpdated,
+  withFileLock,
+  writeFileAtomic,
+  isAlive,
+  ReviewOwnershipError,
+  belongsTo
+};

package/lib/threads.js

@@ -0,0 +1,180 @@
+'use strict';
+
+/**
+ * A review comment as a conversation: the reviewer's comment, then follow-ups
+ * from either side. An agent connected to a review answers in these threads,
+ * so this is where "what is still waiting for an answer" and "what is new
+ * since I last looked" are decided -- once, for the page, the channel and the
+ * background session alike.
+ */
+
+/**
+ * Who wrote the last word in a thread: null for the reviewer, otherwise the
+ * `by` of the last follow-up.
+ *
+ * @param {import('./comments').Comment} comment
+ * @returns {string|null}
+ */
+function lastAuthor(comment) {
+  const followUps = comment.followUps ?? [];
+  return followUps.length === 0 ? null : (followUps[followUps.length - 1].by ?? null);
+}
+
+/**
+ * Threads whose last word is the reviewer's: what an agent has yet to answer.
+ *
+ * @template {import('./comments').Comment} T
+ * @param {T[]} comments
+ * @returns {T[]}
+ */
+function awaitingAnswer(comments) {
+  return comments.filter(comment => lastAuthor(comment) === null);
+}
+
+/** The identity a follow-up is merged by: its key, or what it said and when. */
+function followUpIdentity(followUp) {
+  return followUp.key ?? JSON.stringify([followUp.timestamp ?? null, followUp.text, followUp.by ?? null]);
+}
+
+/**
+ * Every follow-up in either list, once.
+ *
+ * Follow-ups are only ever added -- nothing in the page or the API removes
+ * one -- so a follow-up present on either side is one somebody wrote, and
+ * the union is the only merge that cannot lose an answer. `ours` keeps its
+ * order; follow-ups only `theirs` holds are placed by timestamp.
+ *
+ * @param {import('./comments').FollowUp[]} [ours]
+ * @param {import('./comments').FollowUp[]} [theirs]
+ * @returns {import('./comments').FollowUp[]}
+ */
+function unionFollowUps(ours = [], theirs = []) {
+  const merged = [...ours];
+  const seen = new Set(ours.map(followUpIdentity));
+
+  for (const followUp of theirs) {
+    const identity = followUpIdentity(followUp);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+
+    // After the last entry that is not later than it, so an answer that was
+    // written while this side was adding its own lands where it happened.
+    const at = followUp.timestamp ?? '';
+    let index = merged.length;
+    if (at) {
+      while (index > 0 && (merged[index - 1].timestamp ?? '') > at) index--;
+    }
+    merged.splice(index, 0, followUp);
+  }
+
+  return merged;
+}
+
+/**
+ * Carry over follow-ups a save never saw.
+ *
+ * A tab saves the whole list it holds. An agent may have answered in a thread
+ * after that tab last heard from the server; saving the tab's copy of the
+ * thread as it stands would erase the answer. For every comment present both
+ * in the save and on disk, the follow-ups on disk are kept alongside the
+ * tab's.
+ *
+ * @param {import('./comments').Comment[]} incoming keyed comments being saved
+ * @param {import('./comments').Comment[]} current keyed comments on disk
+ * @returns {import('./comments').Comment[]}
+ */
+function keepFollowUpsFrom(incoming, current) {
+  const onDisk = new Map(current.map(comment => [comment.key, comment]));
+
+  return incoming.map(comment => {
+    const stored = onDisk.get(comment.key);
+    if (!stored?.followUps?.length) return comment;
+
+    const followUps = unionFollowUps(comment.followUps, stored.followUps);
+    return followUps.length === (comment.followUps?.length ?? 0) ? comment : { ...comment, followUps };
+  });
+}
+
+/**
+ * What the reviewer has said in `next` that was not in `prev`: new comments,
+ * and new follow-ups the reviewer wrote. Each comes back once, keyed, so an
+ * agent can be told about it exactly once.
+ *
+ * @param {import('./comments').Comment[]} prev keyed
+ * @param {import('./comments').Comment[]} next keyed
+ * @returns {Array<{comment: import('./comments').Comment, followUp: import('./comments').FollowUp|null}>}
+ */
+function newReviewerMessages(prev, next) {
+  const before = new Map(prev.map(comment => [comment.key, comment]));
+  const messages = [];
+
+  for (const comment of next) {
+    const old = before.get(comment.key);
+    if (!old) {
+      messages.push({ comment, followUp: null });
+    }
+    const known = new Set((old?.followUps ?? []).map(followUpIdentity));
+    for (const followUp of comment.followUps ?? []) {
+      if (followUp.by || known.has(followUpIdentity(followUp))) continue;
+      // A brand-new comment arriving with follow-ups already on it is one
+      // message, not several: the agent is told about the thread once.
+      if (!old) continue;
+      messages.push({ comment, followUp });
+    }
+  }
+
+  return messages;
+}
+
+/**
+ * The thread an agent is being asked to answer, as plain text.
+ *
+ * Shared by every way an agent can be connected, so a background session and
+ * a live one are asked the same question in the same words.
+ *
+ * @param {import('./comments').Comment} comment
+ * @returns {string}
+ */
+function describeThread(comment) {
+  const lines = [`${comment.file}, line ${comment.line}`];
+  if (comment.lineContent !== undefined && comment.lineContent !== null && comment.lineContent !== '') {
+    lines.push(`Line: ${comment.lineContent.trim()}`);
+  }
+  if (comment.selectedText) {
+    lines.push(`Selected: ${comment.selectedText.trim()}`);
+  }
+  lines.push('', `Reviewer: ${comment.text}`);
+  for (const followUp of comment.followUps ?? []) {
+    lines.push(`${followUp.by ? `${followUp.by} (you)` : 'Reviewer'}: ${followUp.text}`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Append an agent's answer to a thread.
+ *
+ * @param {import('./comments').Comment[]} comments keyed
+ * @param {string} key comment to answer
+ * @param {import('./comments').FollowUp} reply
+ * @returns {import('./comments').Comment[]|null} the new list, or null when no comment has that key
+ */
+function appendReply(comments, key, reply) {
+  let found = false;
+  const updated = comments.map(comment => {
+    if (comment.key !== key) return comment;
+    found = true;
+    return { ...comment, followUps: [...(comment.followUps ?? []), reply] };
+  });
+  return found ? updated : null;
+}
+
+module.exports = {
+  lastAuthor,
+  awaitingAnswer,
+  unionFollowUps,
+  keepFollowUpsFrom,
+  newReviewerMessages,
+  describeThread,
+  appendReply,
+  followUpIdentity
+};

package/lib/watch.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { readSavedComments } = require('./store');
+const { commentsFilename } = require('./review');
+
+/**
+ * Hearing about a review changing, whoever changed it.
+ *
+ * The comments file is the source of truth and, now that agents answer in
+ * threads, it has writers other than the page: `reviewer channel` running
+ * inside a Claude Code session, `reviewer reply`, a background session the
+ * server started. Each of them writes the file; everyone interested watches
+ * it. That keeps the writers from needing to know who is listening, or where.
+ *
+ * `fs.watch` gives the change within milliseconds where the platform supports
+ * it. A slow poll runs alongside, because there are filesystems where
+ * `fs.watch` is silently deaf -- network mounts, some containers -- and a
+ * reply that never shows up is worse than one that shows up a second late.
+ */
+
+const DEBOUNCE_MS = 25;
+const POLL_MS = 1500;
+
+/**
+ * Watch one repository's saved comments.
+ *
+ * `onChange` is called with what was read whenever `lastUpdated` moves, and
+ * once at the start with the state as it stands, so a caller never has to
+ * read separately and race the first change.
+ *
+ * @param {string} reviewsDir
+ * @param {string} repoPath
+ * @param {(state: import('./store').SavedReview) => void} onChange
+ * @param {object} [options]
+ * @param {number} [options.pollMs]
+ * @param {(error: Error) => void} [options.onError] a file that cannot be read or parsed; the watch carries on
+ * @returns {{close: () => void, ready: Promise<void>}}
+ */
+function watchComments(reviewsDir, repoPath, onChange, { pollMs = POLL_MS, onError = () => {} } = {}) {
+  const filename = commentsFilename(repoPath);
+  const file = path.join(reviewsDir, filename);
+
+  let closed = false;
+  let lastSeen;
+  let lastStat = null;
+  let timer = null;
+  let reading = null;
+  let again = false;
+
+  const check = async () => {
+    if (closed) return;
+    if (reading) {
+      again = true;
+      return reading;
+    }
+    reading = (async () => {
+      try {
+        const state = await readSavedComments(reviewsDir, repoPath);
+        if (closed) return;
+        if (state.lastUpdated !== lastSeen) {
+          lastSeen = state.lastUpdated;
+          onChange(state);
+        }
+      } catch (error) {
+        // A file caught mid-replace by a writer that is not atomic, or one
+        // hand-edited into invalid JSON. Say so and keep watching: the next
+        // write will be readable.
+        if (!closed) onError(error);
+      }
+    })();
+    try {
+      await reading;
+    } finally {
+      reading = null;
+      if (again && !closed) {
+        again = false;
+        check();
+      }
+    }
+  };
+
+  const schedule = () => {
+    if (closed) return;
+    clearTimeout(timer);
+    timer = setTimeout(check, DEBOUNCE_MS);
+  };
+
+  let watcher = null;
+  try {
+    fs.mkdirSync(reviewsDir, { recursive: true });
+    // The directory, not the file: an atomic write replaces the file, and a
+    // watch on the old one would go quiet after the first save.
+    watcher = fs.watch(reviewsDir, (event, name) => {
+      if (!name || name === filename) schedule();
+    });
+    watcher.on('error', () => {
+      watcher?.close();
+      watcher = null;
+    });
+  } catch {
+    watcher = null; // the poll below still covers it
+  }
+
+  const poll = setInterval(() => {
+    fs.stat(file, (error, stat) => {
+      const signature = error ? null : `${stat.mtimeMs}:${stat.size}`;
+      if (signature !== lastStat) {
+        lastStat = signature;
+        check();
+      }
+    });
+  }, pollMs);
+  poll.unref();
+
+  const ready = check();
+
+  return {
+    ready,
+    close() {
+      closed = true;
+      clearTimeout(timer);
+      clearInterval(poll);
+      watcher?.close();
+    }
+  };
+}
+
+module.exports = { watchComments };

package/man/git-reviewer.1

@@ -17,6 +17,23 @@ git-reviewer, reviewer \- review local git changes in your browser, and hand the
 .IR json | prompt ]
 .RB [ \-\-file
 .IR path ]
+.br
+.B git reviewer connect
+.RI [ repository ]
+.RB [ \-\-session
+.IR id ]
+.RB [ \-\-fork ]
+.RB [ \-\-list ]
+.br
+.B git reviewer reply
+.I key text
+.RB [ \-\-repo
+.IR path ]
+.RB [ \-\-as
+.IR name ]
+.br
+.B git reviewer watch
+.RI [ repository ]
 .SH DESCRIPTION
 Opens the uncommitted changes of a git repository, or its last commit on a
 clean tree, as a pull-request style review in your browser: inline comments
@@ -44,6 +61,36 @@ is the same program under a shorter name.
 .B export
 Print the saved review of a repository to stdout, as JSON or as a prompt for
 a coding agent.
+.TP
+.B connect
+Resume the Claude Code session that worked in the repository, with reviewer
+attached as a channel: every comment written in the review is sent to the
+session as it is written, and the session answers in the thread.
+.B \-\-list
+shows the sessions;
+.B \-\-session
+picks one by id or id prefix;
+.B \-\-fork
+resumes a copy. Claude Code asks once, at startup, to confirm the channel.
+.TP
+.B reply
+Post a reply in a comment thread, as an agent. Inside Claude Code it is
+signed
+.BR claude ,
+elsewhere
+.B agent
+unless
+.B \-\-as
+names who it is from. Exits 1 if no comment has that key.
+.TP
+.B watch
+Print each comment waiting for an answer, then each new comment or reply
+from the reviewer, as one JSON line, until interrupted.
+.TP
+.B channel
+The MCP server
+.B connect
+asks Claude Code to run, speaking JSON-RPC over stdio. Not run by hand.
 .SH OPTIONS
 .TP
 .BR \-p ", " \-\-port " \fIn\fR"