@fullstackhouse/cerber 0.38.0 → 0.39.1

package/dist/core/raised.js

@@ -5,7 +5,8 @@
  * Undecided is not "post": a duplicate the user never looked at is exactly what
  * this exists to keep off the PR. The one place undecided still posts is a
  * resolved thread — somebody marked that problem settled, and a review that
- * found it again in the current code is saying it isn't.
+ * found it again in the current code is saying it isn't. A finding the user
+ * has rewritten is not undecided at all: `rewriteFinding` decides it.
  */
 export function sendTreatment(comment) {
     const raised = comment.alreadyRaised;
@@ -19,6 +20,43 @@ export function sendTreatment(comment) {
         return raised.where.kind === "thread" ? "reply" : "hold";
     return raised.where.kind === "thread" && raised.where.state === "resolved" ? "post" : "hold";
 }
+/**
+ * Rewrite a finding's body — and, where somebody else had raised it, let the
+ * rewrite be the decision.
+ *
+ * An undecided match is Send leaving the duplicate out, and that default is
+ * about one thing: nobody has looked at it yet. Rewriting the finding is
+ * looking at it. The words that would post are no longer the ones the check
+ * compared — they are what the user asked for, by hand or through the chat —
+ * and cerber does not hold back what the user wrote. A finding is compared
+ * once for the same reason (`whatToCompare`): the user who rewrote it is the
+ * one deciding about it.
+ *
+ * The match itself stays, with who raised it, where, and why the two are the
+ * same defect: the cockpit still shows all of it, and "send anyway" toggles
+ * straight back off. A decision already made is left alone — including
+ * `reply`, which keeps answering in their thread, in the new words.
+ *
+ * Only a match that would otherwise be held is decided. On a resolved thread
+ * the default already posts, and writing the decision down there would trade a
+ * state that follows the thread for one that doesn't: the cockpit would stop
+ * saying *why* it posts, and the finding would keep posting if somebody
+ * reopened that thread. Nothing is held, so there is nothing to decide — which
+ * goes for a dropped comment too, where drop decides it and the cockpit shows
+ * no toggle to take it back with.
+ */
+export function rewriteFinding(comment, body) {
+    if (body === comment.body)
+        return comment;
+    const raised = comment.alreadyRaised;
+    const held = comment.status !== "dropped" &&
+        raised != null &&
+        raised.decision === null &&
+        sendTreatment({ alreadyRaised: raised }) === "hold";
+    if (!held)
+        return { ...comment, body };
+    return { ...comment, body, alreadyRaised: { ...raised, decision: "send" } };
+}
 /**
  * Which match a comment keeps when several remarks raised the same thing:
  * the liveliest place first, because that is what decides whether posting it

package/dist/core/revise.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { rewriteFinding } from "./raised.js";
 /** The review as it stands, for restoring later. */
 export function snapshotReview(artifact, at) {
     return {
@@ -43,10 +44,17 @@ export function mergeConcurrentEdits(before, after, current) {
     };
     const merged = current.comments.map((now) => {
         const chosen = userTouched(now.id, now) ? now : fromTurn.get(now.id) ?? now;
+        if (chosen === now)
+            return now;
         // Who else raised a comment is the check's to say, not the turn's: a check
         // that landed while the turn ran — and a decision made about it — is only
         // on disk, and the turn's copy predates both.
-        return chosen === now ? now : { ...chosen, alreadyRaised: now.alreadyRaised };
+        const onDisk = { ...chosen, body: now.body, alreadyRaised: now.alreadyRaised };
+        // The rewrite the turn made still decides an undecided match, as any
+        // rewrite does — measured against the body on disk, so a turn that changed
+        // nothing decides nothing. Never on a sent review: that is a record of what
+        // was posted, and nothing on it is re-decided, here or anywhere else.
+        return current.sent ? { ...onDisk, body: chosen.body } : rewriteFinding(onDisk, chosen.body);
     });
     // Comments the turn itself added are not in `current` yet. Only those: a
     // comment present in both `before` and `after` but missing from `current` is
@@ -138,8 +146,10 @@ export function applyRevisions(artifact, revisions, opts = {}) {
                     ...next,
                     comments: next.comments.map((c) => c.id === revision.commentId
                         ? {
-                            ...c,
-                            body: revision.body,
+                            // A rewrite the user asked for decides a duplicate nobody
+                            // had decided about: what posts is their words now, not the
+                            // ones the check compared (`rewriteFinding`).
+                            ...rewriteFinding(c, revision.body),
                             // Omitted = the turn is not re-grading; null = "not a finding".
                             severity: revision.severity === undefined ? c.severity : revision.severity,
                         }

package/dist/server/index.js

@@ -16,7 +16,7 @@ import { refreshArtifact, userOwnsStatus } from "../core/refresh.js";
 import { withWriter } from "../core/history.js";
 import { TrustRuleError, describeRule, explainRule, parseTrustRule } from "../core/trust.js";
 import { buildReviewPayload, computeCalibration, describeReplyFailures, recordReplies, } from "../core/send.js";
-import { raisedChanged, startRaisedCheck } from "../core/raised.js";
+import { raisedChanged, rewriteFinding, startRaisedCheck } from "../core/raised.js";
 import { checkAlreadyRaised, claimRaisedCheck, finishRaisedCheck, isRaisedCheckRunning, prepareRaisedCheck, releaseRaisedCheck, } from "../runner/raised.js";
 import { listArtifacts, loadArtifact, loadArtifactByKey, saveArtifact, updateArtifactByKey, } from "../core/state.js";
 import { isReviewRunning } from "../runner/inflight.js";
@@ -465,11 +465,19 @@ export async function buildApp(opts) {
             ...a,
             comments: a.comments.map((cm) => cm.id === id
                 ? {
-                    ...cm,
+                    // Rewriting a finding somebody else raised decides it: the words
+                    // that post are the user's, not the ones the check compared. An
+                    // explicit decision in the same request still wins, below. On a
+                    // sent review nothing is re-decided — it is a record of what was
+                    // posted, and `foldRaised` holds the same line.
+                    ...(body.body === undefined
+                        ? cm
+                        : a.sent
+                            ? { ...cm, body: String(body.body) }
+                            : rewriteFinding(cm, String(body.body))),
                     ...(decision.success && body.raisedDecision !== undefined && cm.alreadyRaised
                         ? { alreadyRaised: { ...cm.alreadyRaised, decision: decision.data } }
                         : {}),
-                    ...(body.body !== undefined ? { body: String(body.body) } : {}),
                     ...(body.severity !== undefined
                         ? { severity: SeveritySchema.nullable().parse(body.severity) }
                         : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fullstackhouse/cerber",
-  "version": "0.38.0",
+  "version": "0.39.1",
   "description": "AI code-review cockpit: Claude reviews your PRs into local artifacts; nothing reaches GitHub until you say so.",
   "license": "MIT",
   "keywords": [