@fullstackhouse/cerber 0.5.0 → 0.7.0

package/README.md

@@ -5,8 +5,8 @@ a summary, a chaptered walkthrough of the changes, draft inline comments, and a
 verdict with a confidence score. You go through it in a local web cockpit.
 
 **Nothing reaches GitHub until you explicitly say so.** Cerber's only GitHub
-writes happen when you hit Send (coming in a later phase) — reviewing is 100%
-local and read-only.
+write is the Send button (plus opt-in daemon auto-send you turn on yourself) —
+reviewing is 100% local and read-only.
 
 Named after Cerberus, the gatekeeper — and a sibling of
 [cezar](https://github.com/open-mercato/cezar): cezar runs coding agents,
@@ -48,14 +48,28 @@ Each review is a plain JSON artifact in `~/.cerber/reviews/` (override with
 The cockpit (`cerber serve`) renders the queue and the per-PR walkthrough with
 diffs. Artifacts are plain JSON you can `cat`, edit, or pipe into anything.
 
+### When the PR moves under you
+
+A review is written against one commit, but authors keep pushing. Opening a
+review checks the PR's head and pulls the review forward: comments follow their
+code to its new line numbers, and any whose code is gone are flagged and post
+in the review body instead of inline — GitHub rejects an entire review over one
+comment on a line that is no longer in the diff. Sends carry the reviewed
+commit's SHA, so inline comments land where they were written.
+
+The AI's summary and verdict still describe the commit that was reviewed. To
+get its opinion of the new code, hit **Re-review at the new head** in the
+cockpit (or `cerber review <pr> --force`) — comments you wrote or rewrote are
+carried into the fresh review.
+
 ## Status / roadmap
 
-Early. Current phase: review + read-only cockpit.
+Early, but all six planned phases have shipped.
 
 1. ✅ `cerber review <pr>` + artifact schema + cockpit (read-only)
 2. ✅ Comment editing in the cockpit (edit/approve/drop/add), verdict override,
-   gated **Send** (double-confirm; posts the review via your `gh` — the only
-   GitHub write in the codebase) + `cerber export` to markdown
+   gated **Send** (one deliberate click; posts the review via your `gh` — the
+   only GitHub write in the codebase) + `cerber export` to markdown
 3. ✅ `--awaiting-me` discovery, parallel runs (`--parallel`, default 3),
    freshness skip (same head SHA → no re-run; `--force` overrides), queue stats
 4. ✅ Daemon/VPS mode: `cerber serve --daemon` polls for PRs awaiting your
@@ -64,6 +78,9 @@ Early. Current phase: review + read-only cockpit.
 5. ✅ Confidence calibration (`cerber stats`), shadow-mode auto-send (default
    in daemon: logs what would be sent), opt-in `--auto-send` (approve-only,
    `--auto-send-threshold`, default 90%)
+6. ✅ Reviews keep up with the PR: opening one re-anchors its comments onto new
+   commits, flags the ones whose code is gone, and offers a re-review that
+   keeps everything you wrote
 
 ## Running on a VPS
 

package/dist/cli/index.js

@@ -151,6 +151,7 @@ program
         event: payload.event,
         body: payload.body,
         comments: payload.comments,
+        commitId: payload.commitId,
     });
     await updateArtifactByKey(artifactKey(id), (a) => ({
         ...a,

package/dist/core/anchor.js

@@ -0,0 +1,73 @@
+import { newSideLineText } from "./diff.js";
+export function reanchorComments(comments, oldDiff, newDiff) {
+    const before = newSideLineText(oldDiff);
+    const after = newSideLineText(newDiff);
+    const results = [];
+    const next = comments.map((c) => {
+        const result = reanchorOne(c, before, after);
+        results.push(result);
+        switch (result.state) {
+            case "moved":
+                return {
+                    ...c,
+                    line: result.to,
+                    // Keep pointing at where the human wrote it, however far it travels.
+                    originalLine: c.originalLine ?? result.from,
+                    drifted: false,
+                };
+            case "drifted":
+                // Keep the stale line number: it is the only trace of what the comment
+                // was about, and the send path folds it into the body either way.
+                return { ...c, drifted: true };
+            default:
+                return c.drifted ? { ...c, drifted: false } : c;
+        }
+    });
+    return {
+        comments: next,
+        results,
+        moved: results.filter((r) => r.state === "moved").length,
+        drifted: results.filter((r) => r.state === "drifted").length,
+    };
+}
+function reanchorOne(comment, before, after) {
+    const { id, path, line } = comment;
+    if (line == null)
+        return { id, state: "unanchored", from: null, to: null };
+    const oldLines = before.get(path);
+    const newLines = after.get(path);
+    const oldText = oldLines?.get(line);
+    // No text to match on (the comment was already off-diff), or the file is not
+    // in the new diff at all — either way there is nothing to anchor to.
+    if (!oldLines || !newLines || oldText === undefined) {
+        return { id, state: "drifted", from: line, to: null };
+    }
+    if (newLines.get(line) === oldText) {
+        return { id, state: "unchanged", from: line, to: line };
+    }
+    const candidates = [...newLines].filter(([, text]) => text === oldText).map(([n]) => n);
+    if (candidates.length === 0)
+        return { id, state: "drifted", from: line, to: null };
+    if (candidates.length === 1)
+        return { id, state: "moved", from: line, to: candidates[0] };
+    // The line alone is ambiguous ("}", a blank line, a repeated call). Ask the
+    // neighbours: keep only candidates whose surrounding lines match too.
+    const withContext = candidates.filter((n) => contextMatches(oldLines, line, newLines, n));
+    if (withContext.length === 1)
+        return { id, state: "moved", from: line, to: withContext[0] };
+    return { id, state: "drifted", from: line, to: null };
+}
+const CONTEXT = 3;
+function contextMatches(oldLines, oldLine, newLines, newLine) {
+    for (let offset = -CONTEXT; offset <= CONTEXT; offset++) {
+        if (offset === 0)
+            continue;
+        const oldText = oldLines.get(oldLine + offset);
+        // Outside the old hunk there is nothing to compare — treat as neutral.
+        if (oldText === undefined)
+            continue;
+        if (newLines.get(newLine + offset) !== oldText)
+            return false;
+    }
+    return true;
+}

package/dist/core/artifact.js

@@ -12,6 +12,10 @@ export const CommentSchema = z.object({
     status: z.enum(["draft", "approved", "dropped"]).default("draft"),
     /** Set when the user edits an AI comment's body — calibration signal. */
     editedByUser: z.boolean().default(false),
+    /** Line this comment was written against, when a refresh has since moved it. */
+    originalLine: z.number().int().positive().nullable().default(null),
+    /** The commented line no longer exists in the diff — it can't post inline. */
+    drifted: z.boolean().default(false),
 });
 /** A logical group of changes — the unit of the review walkthrough. */
 export const ChapterSchema = z.object({
@@ -37,6 +41,8 @@ export const PrInfoSchema = z.object({
     baseRefName: z.string(),
     headRefName: z.string(),
     headSha: z.string().default(""),
+    /** OPEN | CLOSED | MERGED, as of the last fetch. */
+    state: z.enum(["OPEN", "CLOSED", "MERGED"]).default("OPEN"),
     additions: z.number().int().default(0),
     deletions: z.number().int().default(0),
     changedFiles: z.number().int().default(0),
@@ -64,6 +70,16 @@ export const SentInfoSchema = z.object({
     /** True when the daemon auto-sent this review (opt-in --auto-send). */
     auto: z.boolean().default(false),
 });
+/** Result of pulling a review forward onto a newer head commit. */
+export const RefreshInfoSchema = z.object({
+    at: z.string(),
+    fromSha: z.string(),
+    toSha: z.string(),
+    /** Comments whose line number changed but whose code was found again. */
+    moved: z.number().int().default(0),
+    /** Comments whose line is gone from the new diff — they now post in the body. */
+    drifted: z.number().int().default(0),
+});
 /** What actually happened vs what the AI proposed — recorded at send time. */
 export const CalibrationSchema = z.object({
     aiRecommendation: z.enum(["approve", "comment", "request_changes"]).nullable(),
@@ -92,6 +108,8 @@ export const ArtifactSchema = z.object({
     run: RunInfoSchema.nullable().default(null),
     /** Set once the review was sent to GitHub (explicitly, or via opt-in auto-send). */
     sent: SentInfoSchema.nullable().default(null),
+    /** Last time this review was pulled forward onto a newer head commit. */
+    refresh: RefreshInfoSchema.nullable().default(null),
     calibration: CalibrationSchema.nullable().default(null),
 });
 /** What the AI must return. Subset of the artifact; cerber owns the rest. */

package/dist/core/diff.js

@@ -43,13 +43,13 @@ export function patchForFiles(diff, files) {
         .join("\n");
 }
 /**
- * Line numbers (new side of the diff) that a GitHub review comment can attach
- * to, per file: added and context lines inside hunks.
+ * New-side lines of the diff with their text, per file: added and context
+ * lines inside hunks — exactly the lines a GitHub comment can attach to.
  */
-export function newSideLines(diff) {
+export function newSideLineText(diff) {
     const result = new Map();
     for (const { path, patch } of splitDiffByFile(diff)) {
-        const lines = new Set();
+        const lines = new Map();
         let newLine = 0;
         let inHunk = false;
         const patchLines = patch.split("\n");
@@ -68,7 +68,7 @@ export function newSideLines(diff) {
             if (line.startsWith("\\"))
                 continue; // ""
             if (line.startsWith("+") || line.startsWith(" ") || line === "") {
-                lines.add(newLine);
+                lines.set(newLine, line === "" ? "" : line.slice(1));
                 newLine++;
             }
             // "-" lines belong to the old side only.
@@ -77,6 +77,17 @@ export function newSideLines(diff) {
     }
     return result;
 }
+/**
+ * Line numbers (new side of the diff) that a GitHub review comment can attach
+ * to, per file: added and context lines inside hunks.
+ */
+export function newSideLines(diff) {
+    const result = new Map();
+    for (const [path, lines] of newSideLineText(diff)) {
+        result.set(path, new Set(lines.keys()));
+    }
+    return result;
+}
 /** Paths present in the diff but not claimed by any chapter. */
 export function unclaimedFiles(diff, chapters) {
     const claimed = new Set(chapters.flatMap((c) => c.files));

package/dist/core/gh.js

@@ -45,7 +45,7 @@ export async function fetchPrInfo(ref) {
         "--repo",
         `${ref.owner}/${ref.repo}`,
         "--json",
-        "title,url,author,body,baseRefName,headRefName,headRefOid,additions,deletions,changedFiles",
+        "title,url,author,body,baseRefName,headRefName,headRefOid,additions,deletions,changedFiles,state",
     ]);
     const raw = JSON.parse(out);
     return PrInfoSchema.parse({
@@ -59,6 +59,7 @@ export async function fetchPrInfo(ref) {
         baseRefName: raw.baseRefName,
         headRefName: raw.headRefName,
         headSha: raw.headRefOid ?? "",
+        state: raw.state ?? "OPEN",
         additions: raw.additions ?? 0,
         deletions: raw.deletions ?? 0,
         changedFiles: raw.changedFiles ?? 0,
@@ -119,15 +120,19 @@ export async function submitReview(ref, payload) {
         "--input",
         "-",
     ];
+    const { commitId, ...rest } = payload;
+    const body = commitId ? { ...rest, commit_id: commitId } : rest;
     const { execFile: ef } = await import("node:child_process");
     const out = await new Promise((resolve, reject) => {
         const child = ef("gh", args, { maxBuffer: MAX_BUFFER }, (err, stdout, stderr) => {
+            // gh only prints the top-level "message" ("Unprocessable Entity"); the useful
+            // part is the errors[] array it leaves in the response body on stdout.
             if (err)
-                reject(new Error(`gh api reviews failed: ${stderr?.trim() || err.message}`));
+                reject(new Error(`gh api reviews failed: ${ghErrorDetail(stderr, stdout) || err.message}`));
             else
                 resolve(stdout);
         });
-        child.stdin.write(JSON.stringify(payload));
+        child.stdin.write(JSON.stringify(body));
         child.stdin.end();
     });
     try {
@@ -138,3 +143,24 @@ export async function submitReview(ref, payload) {
         return { url: null };
     }
 }
+/** Combine gh's stderr with the details GitHub returns in the response body. */
+export function ghErrorDetail(stderr, stdout) {
+    const head = stderr?.trim() ?? "";
+    let details = [];
+    try {
+        const res = JSON.parse(stdout ?? "");
+        details = (Array.isArray(res.errors) ? res.errors : [])
+            .map((e) => (typeof e === "string" ? e : describeGhError(e)))
+            .filter((s) => s.length > 0 && !head.includes(s));
+    }
+    catch {
+        // Non-JSON body (rate-limit HTML, empty response) — stderr is all we have.
+    }
+    return [head, ...details].filter(Boolean).join(" — ");
+}
+function describeGhError(e) {
+    if (typeof e.message === "string")
+        return e.message;
+    const where = [e.resource, e.field].filter((v) => typeof v === "string").join(".");
+    return [where, e.code].filter(Boolean).join(": ");
+}

package/dist/core/refresh.js

@@ -0,0 +1,54 @@
+import { reanchorComments } from "./anchor.js";
+/**
+ * Pull a review forward onto the PR's current head: swap in the new diff and
+ * carry every comment across, re-anchored to the code it was written about.
+ *
+ * The AI's summary, chapters and verdict still describe the commit that was
+ * reviewed — this only keeps the comments postable. Re-reviewing is the
+ * (expensive) way to get the AI's opinion of the new code.
+ */
+export function refreshArtifact(artifact, pr, diff) {
+    if (artifact.pr.headSha !== "" && artifact.pr.headSha === pr.headSha) {
+        return { artifact, changed: false, moved: 0, drifted: 0, results: [] };
+    }
+    const { comments, results, moved, drifted } = reanchorComments(artifact.comments, artifact.diff, diff);
+    return {
+        artifact: {
+            ...artifact,
+            pr,
+            diff,
+            comments,
+            updatedAt: new Date().toISOString(),
+            refresh: {
+                at: new Date().toISOString(),
+                fromSha: artifact.pr.headSha,
+                toSha: pr.headSha,
+                moved,
+                drifted,
+            },
+        },
+        changed: true,
+        moved,
+        drifted,
+        results,
+    };
+}
+/**
+ * Comments a human put work into: their own, and AI ones they rewrote.
+ * A re-review regenerates everything the AI said, but must not silently bin
+ * these — see carryOverComments.
+ */
+export function humanComments(artifact) {
+    return artifact.comments.filter((c) => c.origin === "user" || c.editedByUser);
+}
+/**
+ * Carry a previous review's human comments into a fresh one, re-anchored to
+ * the new diff. AI comments are dropped: the new run just regenerated them.
+ */
+export function carryOverComments(previous, fresh) {
+    const human = humanComments(previous);
+    if (human.length === 0)
+        return { comments: fresh.comments, carried: 0, drifted: 0 };
+    const { comments, drifted } = reanchorComments(human, previous.diff, fresh.diff);
+    return { comments: [...fresh.comments, ...comments], carried: comments.length, drifted };
+}

package/dist/core/send.js

@@ -13,7 +13,10 @@ export function buildReviewPayload(artifact, event) {
     const inline = [];
     const folded = [];
     for (const c of active) {
-        if (c.line != null && anchorable.get(c.path)?.has(c.line)) {
+        // A drifted comment's line number may still exist in the diff, but it now
+        // holds different code — posting there would point the author at something
+        // the comment was never about.
+        if (!c.drifted && c.line != null && anchorable.get(c.path)?.has(c.line)) {
             inline.push({ path: c.path, line: c.line, side: "RIGHT", body: c.body });
         }
         else {
@@ -33,11 +36,20 @@ export function buildReviewPayload(artifact, event) {
     if (folded.length > 0) {
         parts.push("", "## Additional notes", "");
         for (const c of folded) {
-            parts.push(`- \`${c.path}${c.line != null ? `:${c.line}` : ""}\` — ${c.body}`);
+            // A drifted comment's line no longer exists, so name it as "was at" —
+            // pointing a reader at a line number that moved is worse than no number.
+            const at = c.line != null ? `:${c.drifted ? `~${c.line}` : c.line}` : "";
+            parts.push(`- \`${c.path}${at}\` — ${c.body}`);
         }
     }
     parts.push("", "---", "_Reviewed with [cerber](https://github.com/fullstackhouse/cerber) 🐕 — drafted by AI, sent by a human._");
-    return { event, body: parts.join("\n").trim(), comments: inline, folded };
+    return {
+        event,
+        body: parts.join("\n").trim(),
+        comments: inline,
+        folded,
+        commitId: artifact.pr.headSha || undefined,
+    };
 }
 /** Snapshot of AI-proposal vs human-final, recorded at send time for `cerber stats`. */
 export function computeCalibration(artifact, event) {

package/dist/core/state.js

@@ -76,6 +76,31 @@ export async function updateArtifactByKey(key, mutate) {
     await saveArtifact(updated);
     return updated;
 }
+/**
+ * Clear "running" statuses left behind by a process that died mid-review.
+ * Nothing in a freshly started process is running, so anything still marked
+ * running is a leftover — without this it stays wedged forever, with no way to
+ * retry it from the cockpit. A `cerber review` running in another terminal is
+ * the one false positive; it overwrites the artifact when it finishes anyway.
+ */
+export async function reconcileRunning() {
+    const artifacts = await listArtifacts();
+    let cleared = 0;
+    for (const artifact of artifacts) {
+        if (artifact.status !== "running")
+            continue;
+        await saveArtifact({
+            ...artifact,
+            status: "failed",
+            updatedAt: new Date().toISOString(),
+            run: artifact.run
+                ? { ...artifact.run, error: "interrupted — cerber restarted while this review was running" }
+                : null,
+        });
+        cleared++;
+    }
+    return cleared;
+}
 export async function listArtifacts() {
     let entries;
     try {

package/dist/runner/inflight.js

@@ -0,0 +1,33 @@
+/**
+ * Which reviews this process is running right now.
+ *
+ * `cerber serve --daemon` starts reviews from a timer while the cockpit can
+ * start them from a click. Both write the same artifact file, so two runs for
+ * one PR would race and the loser's work would vanish. The daemon's `pool`
+ * only bounds its own concurrency; this is what the two paths share.
+ *
+ * In-process only: a `cerber review` in another terminal is invisible here.
+ * That's the pre-existing situation and the artifact write is atomic, so the
+ * cost is a wasted run, not a corrupt file.
+ */
+const running = new Set();
+export class ReviewInProgressError extends Error {
+    id;
+    constructor(id) {
+        super(`a review of ${id} is already running`);
+        this.id = id;
+        this.name = "ReviewInProgressError";
+    }
+}
+/** Claim the slot for an artifact id. Throws if it is already claimed. */
+export function beginReview(id) {
+    if (running.has(id))
+        throw new ReviewInProgressError(id);
+    running.add(id);
+}
+export function endReview(id) {
+    running.delete(id);
+}
+export function isReviewRunning(id) {
+    return running.has(id);
+}

package/dist/runner/prompt.js

@@ -8,12 +8,12 @@ export function buildReviewPrompt(pr, diff) {
 Respond with ONLY a JSON object (no markdown fences, no prose before or after) matching exactly this shape:
 
 {
-  "summary": "markdown — what this PR actually does and why, written top-down: problem first, then the solution, then notable technical details. 1-3 paragraphs.",
+  "summary": "markdown — what this PR actually does and why, written top-down: problem first in plain language, then the solution, then notable technical details. A reader should be able to stop after any paragraph with a correct, just less detailed, picture. 1-3 paragraphs.",
   "chapters": [
     {
       "id": "short-kebab-id",
       "title": "Human title of this logical group of changes",
-      "explanation": "markdown — what this group changes and why, what to pay attention to",
+      "explanation": "markdown — 2-3 plain sentences: what this group changes, why, and what to look at closely",
       "files": ["path/to/file.ts", "path/other.ts"]
     }
   ],
@@ -21,7 +21,7 @@ Respond with ONLY a JSON object (no markdown fences, no prose before or after) m
     {
       "path": "path/to/file.ts",
       "line": 42,
-      "body": "markdown — the review comment. Concrete, actionable, kind.",
+      "body": "markdown — the review comment. First sentence states the problem plainly; then the evidence or fix. Concrete, actionable, kind.",
       "chapterId": "short-kebab-id"
     }
   ],
@@ -32,6 +32,13 @@ Respond with ONLY a JSON object (no markdown fences, no prose before or after) m
   }
 }
 
+Writing style (applies to every markdown field):
+- Write like one human explaining to another: plain words, short sentences, no jargon. Someone who has NOT read the diff should follow every sentence.
+- Lead with the point. State the claim first, support it after. No hedging chains, no em-dash clause stacks.
+- Keep comments to ~3 sentences unless a code suggestion needs more. Length must buy clarity, not cover uncertainty — if you are unsure, say so in one plain sentence.
+- Do NOT imitate the PR description's writing style. Keep this plain register even when the PR itself is dense or writerly.
+- Describe the effect a person would see before the mechanism behind it. Not: "A stray closing code fence with prose on the same line left the block open, rendering the conditions below as code." But: "Also fixes a markdown typo: a code block was never closed, so everything after it displayed as code."
+
 Rules:
 - Group ALL changed files into chapters that tell the story of the PR (schema first, then logic, then tests, etc). Every changed file must appear in exactly one chapter.
 - "line" is the line number in the NEW version of the file (the "+" side of the diff). Use null for file-level comments. Only reference lines that appear in the diff.

package/dist/runner/review.js

@@ -1,8 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { AiReviewSchema, SCHEMA_VERSION, artifactId, } from "../core/artifact.js";
 import { fetchPrDiff, fetchPrInfo } from "../core/gh.js";
+import { carryOverComments } from "../core/refresh.js";
 import { loadArtifact, saveArtifact } from "../core/state.js";
 import { extractJson, runClaude } from "./claude.js";
+import { beginReview, endReview } from "./inflight.js";
 import { buildReviewPrompt, buildRetryPrompt } from "./prompt.js";
 /** Statuses that a fresh artifact can keep without a re-run. */
 const FRESH_STATUSES = new Set(["ready", "reviewed", "sent", "skipped"]);
@@ -11,12 +13,21 @@ const FRESH_STATUSES = new Set(["ready", "reviewed", "sent", "skipped"]);
  * Everything stays local — nothing is ever written to GitHub.
  */
 export async function reviewPr(ref, opts = {}) {
+    beginReview(artifactId(ref));
+    try {
+        return await runReview(ref, opts);
+    }
+    finally {
+        endReview(artifactId(ref));
+    }
+}
+async function runReview(ref, opts) {
     const log = opts.onProgress ?? (() => { });
     const now = () => new Date().toISOString();
     log(`Fetching ${ref.owner}/${ref.repo}#${ref.number}…`);
     const pr = await fetchPrInfo(ref);
+    const existing = await loadArtifact(artifactId(pr));
     if (!opts.force) {
-        const existing = await loadArtifact(artifactId(pr));
         if (existing &&
             FRESH_STATUSES.has(existing.status) &&
             existing.pr.headSha !== "" &&
@@ -30,7 +41,7 @@ export async function reviewPr(ref, opts = {}) {
         schemaVersion: SCHEMA_VERSION,
         id: artifactId(pr),
         status: "running",
-        createdAt: now(),
+        createdAt: existing?.createdAt ?? now(),
         updatedAt: now(),
         pr,
         diff,
@@ -40,6 +51,7 @@ export async function reviewPr(ref, opts = {}) {
         verdict: null,
         run: { model: opts.model ?? null, startedAt: now(), finishedAt: null, costUsd: null, error: null },
         sent: null,
+        refresh: null,
         calibration: null,
     };
     await saveArtifact(artifact);
@@ -72,6 +84,8 @@ export async function reviewPr(ref, opts = {}) {
                 origin: "ai",
                 status: "draft",
                 editedByUser: false,
+                originalLine: null,
+                drifted: false,
             })),
             verdict: review.ai.verdict,
             run: {
@@ -82,6 +96,16 @@ export async function reviewPr(ref, opts = {}) {
                 error: null,
             },
         };
+        // A re-review regenerates the AI's comments, but the human's own comments
+        // and their rewrites of AI ones are work the run must not throw away.
+        if (existing) {
+            const { comments, carried, drifted } = carryOverComments(existing, artifact);
+            if (carried > 0) {
+                artifact = { ...artifact, comments };
+                log(`Carried over ${carried} comment(s) you wrote or edited` +
+                    (drifted > 0 ? `; ${drifted} no longer match the diff and will post in the body.` : "."));
+            }
+        }
     }
     catch (err) {
         artifact = {

package/dist/server/daemon.js

@@ -3,6 +3,7 @@ import { evaluateAutoSend } from "../core/autosend.js";
 import { searchAwaitingMe, submitReview } from "../core/gh.js";
 import { buildReviewPayload, computeCalibration } from "../core/send.js";
 import { appendAutoSendLog, updateArtifactByKey } from "../core/state.js";
+import { ReviewInProgressError } from "../runner/inflight.js";
 import { pool, reviewPr } from "../runner/review.js";
 /**
  * Poll GitHub for PRs awaiting the user's review and keep their artifacts
@@ -62,6 +63,11 @@ export function startDaemon(opts) {
                     }
                 }
                 catch (err) {
+                    if (err instanceof ReviewInProgressError) {
+                        // The cockpit (or an earlier, slower poll) is already on it.
+                        skipped++;
+                        return;
+                    }
                     failed++;
                     status.errors++;
                     log(`[${label}] failed: ${err instanceof Error ? err.message : err}`);
@@ -106,7 +112,7 @@ export function startDaemon(opts) {
         }
         try {
             const payload = buildReviewPayload(artifact, "APPROVE");
-            const { url } = await submitReview({ owner: artifact.pr.owner, repo: artifact.pr.repo, number: artifact.pr.number }, { event: payload.event, body: payload.body, comments: payload.comments });
+            const { url } = await submitReview({ owner: artifact.pr.owner, repo: artifact.pr.repo, number: artifact.pr.number }, { event: payload.event, body: payload.body, comments: payload.comments, commitId: payload.commitId });
             await updateArtifactByKey(artifactKey(artifact.id), (a) => ({
                 ...a,
                 status: "sent",