From 63f78ae9fc86b3d8b54d38891849415482d1c827 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:10:01 -0400
Subject: [PATCH 01/15] fix(diff): decode git-quoted paths from the PR diff

GitHub's diff C-quotes non-ASCII paths and paths with a quote, a
backslash, or a control character. parse-diff keeps the escapes, so the
workspace read, diff exclusion, and inline comments saw a path that does
not exist. Decode from and to right after parsing; a malformed quote is
kept as received with a warning.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                               |   2 +-
 src/__tests__/orchestrate.test.ts       |  38 +++++
 src/diff/__tests__/quoted-paths.test.ts | 177 ++++++++++++++++++++++++
 src/diff/quoted-paths.ts                |  95 +++++++++++++
 src/orchestrate.ts                      |   3 +-
 5 files changed, 313 insertions(+), 2 deletions(-)
 create mode 100644 src/diff/__tests__/quoted-paths.test.ts
 create mode 100644 src/diff/quoted-paths.ts

diff --git a/AGENTS.md b/AGENTS.md
index 2399024..1d75fe0 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -27,7 +27,7 @@ src/
   logger.ts                # structured JSON logger — levels, child contexts, lazy props
   github/                  # GitHub I/O: event payload → PrContext, octokit wrappers (diff fetch, review posting)
   openrouter/              # OpenRouter I/O: @openrouter/sdk wrapper, per-attempt and shared review deadlines, retry and fallback ladder (HTTP errors, timeouts, invalid structured output), cost summary
-  diff/                    # pure transforms over parse-diff output + diff-level exclusion (patterns, gitattributes linguist rules, wildcard safety cap)
+  diff/                    # pure transforms over parse-diff output: git-quoted path decoding, annotation, commentable lines, diff-level exclusion (patterns, gitattributes linguist rules, wildcard safety cap)
   context/                 # workspace I/O: conventions file, root .gitattributes, changed files, import-trace scan, doc-mention scan, priority docs
   review/                  # pure review logic: finding schema, phases + stage dispatch, prompt, non-finding filter, unknown-file filter, cross-phase merge, path normalization, selection, comment mapping, title similarity, context notes, summary
   orchestrate.ts           # pipeline + createPromptedGenerateFindings — fully testable with stub clients
diff --git a/src/__tests__/orchestrate.test.ts b/src/__tests__/orchestrate.test.ts
index 24a422c..b8644cf 100644
--- a/src/__tests__/orchestrate.test.ts
+++ b/src/__tests__/orchestrate.test.ts
@@ -977,6 +977,44 @@ describe("orchestrate", () => {
   })
 
   describe("context wiring", () => {
+    it("reads and comments on a git-quoted non-ASCII path under its decoded name", async () => {
+      const quotedPathDiff = String.raw`diff --git "a/nn/0016_\303\245-f\303\270de.md" "b/nn/0016_\303\245-f\303\270de.md"
+index 1111111..2222222 100644
+--- "a/nn/0016_\303\245-f\303\270de.md"
++++ "b/nn/0016_\303\245-f\303\270de.md"
+@@ -1 +1 @@
+-old line
++new line
+`
+      const decodedPath = "nn/0016_å-føde.md"
+      const finding = makeFinding({ file: decodedPath, line: 1 })
+      const stubs = makeOrchestrateDeps({
+        githubClient: {
+          fetchDiff: async () => ({ kind: "ok" as const, diff: quotedPathDiff }),
+        },
+        fixtureResult: { review: { analysis: "checked", findings: [finding] } },
+      })
+
+      await orchestrate(stubs.deps, createTestLogger())
+
+      expect(stubs.readChangedFilesCalls.map((call) => call.changedPaths)).toEqual([[decodedPath]])
+      const expectedComments = mapFindingsToReview({
+        findings: [withRoutedModel(finding, "test/model")],
+        commentableByPath: new Map([
+          [decodedPath, { rightLines: new Set([1]), hunkRanges: [{ start: 1, end: 1 }] }],
+        ]),
+      }).comments
+      expect(stubs.postFindingsReviewCalls).toEqual([
+        {
+          prNumber: 7,
+          commitId: fixturePrContext.headSha,
+          body: REVIEW_MARKER,
+          comments: expectedComments,
+        },
+      ])
+      expect(expectedComments.map((comment) => comment.path)).toEqual([decodedPath])
+    })
+
     it("keeps a priority doc in the rendered prompt when changed files use the rest of the budget", async () => {
       const priorityDocContent = "# Review reference\nCheck API behavior."
       const priorityDocTokens = estimateTokens(priorityDocContent)
diff --git a/src/diff/__tests__/quoted-paths.test.ts b/src/diff/__tests__/quoted-paths.test.ts
new file mode 100644
index 0000000..44b0dc7
--- /dev/null
+++ b/src/diff/__tests__/quoted-paths.test.ts
@@ -0,0 +1,177 @@
+import parseDiff, { type File } from "parse-diff"
+import { describe, expect, it } from "vitest"
+import { createTestLogger } from "../../__tests__/test-logger.js"
+import { decodeQuotedFilePaths, decodeQuotedPath } from "../quoted-paths.js"
+
+const makeFile = (overrides: Partial<File> = {}): File => ({
+  chunks: [],
+  additions: 1,
+  deletions: 1,
+  from: "src/app.ts",
+  to: "src/app.ts",
+  ...overrides,
+})
+
+describe("decodeQuotedPath", () => {
+  it.each([
+    {
+      label: "two-byte UTF-8 octal escapes",
+      path: String.raw`nn/0016_\303\245-f\303\270de.md`,
+      expected: "nn/0016_å-føde.md",
+    },
+    {
+      label: "three-byte UTF-8 octal escapes",
+      path: String.raw`docs/\341\213\265.md`,
+      expected: "docs/ድ.md",
+    },
+    {
+      label: "escaped double quotes",
+      path: String.raw`say \"hi\".md`,
+      expected: 'say "hi".md',
+    },
+    {
+      label: "an escaped backslash",
+      path: String.raw`back\\slash.md`,
+      expected: "back\\slash.md",
+    },
+    {
+      label: "a single-character control escape",
+      path: String.raw`tab\there.md`,
+      expected: "tab\there.md",
+    },
+    {
+      label: "raw non-ASCII text beside an escape",
+      path: String.raw`å\\b.md`,
+      expected: "å\\b.md",
+    },
+  ])("decodes $label", ({ path, expected }) => {
+    expect(decodeQuotedPath(path)).toEqual({ kind: "decoded", path: expected })
+  })
+
+  it.each([
+    { label: "a plain path", path: "src/app.ts" },
+    { label: "a path with spaces", path: "docs/plain space.md" },
+    { label: "the /dev/null placeholder", path: "/dev/null" },
+  ])("reports $label as unquoted", ({ path }) => {
+    expect(decodeQuotedPath(path)).toEqual({ kind: "unquoted" })
+  })
+
+  it.each([
+    {
+      // parse-diff drops the escaped backslash of a quoted path that ends in one
+      label: "a lone trailing backslash",
+      path: "ends-with\\",
+      reason: "unrecognized escape",
+    },
+    {
+      label: "an unknown escape character",
+      path: String.raw`bad\x.md`,
+      reason: "unrecognized escape",
+    },
+    {
+      label: "an octal escape above one byte",
+      path: String.raw`bad\400.md`,
+      reason: "unrecognized escape",
+    },
+    {
+      label: "an octal escape with too few digits",
+      path: String.raw`bad\30.md`,
+      reason: "unrecognized escape",
+    },
+    {
+      label: "escaped bytes that are not UTF-8",
+      path: String.raw`caf\351.md`,
+      reason: "escaped bytes are not valid UTF-8",
+    },
+  ])("rejects $label as malformed", ({ path, reason }) => {
+    expect(decodeQuotedPath(path)).toEqual({ kind: "malformed", reason })
+  })
+})
+
+describe("decodeQuotedFilePaths", () => {
+  it("decodes both paths of a quoted rename parsed by parse-diff", () => {
+    const renameDiff = String.raw`diff --git "a/docs/\341\213\265.md" "b/docs/\341\213\265-new.md"
+similarity index 100%
+rename from "docs/\341\213\265.md"
+rename to "docs/\341\213\265-new.md"`
+
+    const decoded = decodeQuotedFilePaths(parseDiff(renameDiff), createTestLogger())
+
+    expect(decoded).toEqual([
+      { chunks: [], additions: 0, deletions: 0, from: "docs/ድ.md", to: "docs/ድ-new.md" },
+    ])
+  })
+
+  it("decodes an added file and keeps its /dev/null old path", () => {
+    const file = makeFile({ new: true, from: "/dev/null", to: String.raw`\303\245.md` })
+
+    expect(decodeQuotedFilePaths([file], createTestLogger())).toEqual([
+      { ...file, from: "/dev/null", to: "å.md" },
+    ])
+  })
+
+  it("decodes a deleted file and keeps its /dev/null new path", () => {
+    const file = makeFile({ deleted: true, from: String.raw`\303\245.md`, to: "/dev/null" })
+
+    expect(decodeQuotedFilePaths([file], createTestLogger())).toEqual([
+      { ...file, from: "å.md", to: "/dev/null" },
+    ])
+  })
+
+  it("leaves an absent old path absent", () => {
+    const file: File = { chunks: [], additions: 0, deletions: 0, to: String.raw`\303\245.png` }
+
+    expect(decodeQuotedFilePaths([file], createTestLogger())).toStrictEqual([
+      { chunks: [], additions: 0, deletions: 0, to: "å.png" },
+    ])
+  })
+
+  it("returns unquoted files unchanged without logging", () => {
+    const file = makeFile()
+    const logger = createTestLogger()
+
+    expect(decodeQuotedFilePaths([file], logger)).toEqual([file])
+    expect(logger.messages).toEqual([])
+  })
+
+  it("logs each decoded path at debug", () => {
+    const logger = createTestLogger()
+
+    decodeQuotedFilePaths(
+      [makeFile({ from: String.raw`\303\245.md`, to: String.raw`\303\270.md` })],
+      logger,
+    )
+
+    expect(logger.messages).toEqual([
+      {
+        level: "debug",
+        message: "decoded quoted diff path",
+        data: { quotedPath: String.raw`\303\245.md`, path: "å.md" },
+      },
+      {
+        level: "debug",
+        message: "decoded quoted diff path",
+        data: { quotedPath: String.raw`\303\270.md`, path: "ø.md" },
+      },
+    ])
+  })
+
+  it("keeps a malformed path as received and warns", () => {
+    const file = makeFile({ from: String.raw`caf\351.md`, to: String.raw`caf\351.md` })
+    const logger = createTestLogger()
+
+    expect(decodeQuotedFilePaths([file], logger)).toEqual([file])
+    expect(logger.messages).toEqual([
+      {
+        level: "warn",
+        message: "malformed quoted diff path — kept as received",
+        data: { path: String.raw`caf\351.md`, reason: "escaped bytes are not valid UTF-8" },
+      },
+      {
+        level: "warn",
+        message: "malformed quoted diff path — kept as received",
+        data: { path: String.raw`caf\351.md`, reason: "escaped bytes are not valid UTF-8" },
+      },
+    ])
+  })
+})
diff --git a/src/diff/quoted-paths.ts b/src/diff/quoted-paths.ts
new file mode 100644
index 0000000..8f0251f
--- /dev/null
+++ b/src/diff/quoted-paths.ts
@@ -0,0 +1,95 @@
+import { isUtf8 } from "node:buffer"
+import type { File } from "parse-diff"
+import type { Logger } from "../logger.js"
+
+export type QuotedPathDecoding =
+  { kind: "unquoted" } | { kind: "decoded"; path: string } | { kind: "malformed"; reason: string }
+
+/**
+ * One token of a path in git's C-style quoting, matching what git's
+ * unquote_c_style accepts.
+ * - literal: a run of characters with no backslash.
+ * - octal: three octal digits for one byte. Git writes the first digit as 0-3.
+ * - The unnamed last branch takes any other backslash and the character after
+ *   it. CHARACTER_ESCAPE_BYTES decides whether that pair is a valid escape.
+ */
+const QUOTED_PATH_TOKEN = /(?<literal>[^\\]+)|\\(?<octal>[0-3][0-7]{2})|\\.?/gs
+
+/** Git's single-character escapes and the byte each stands for. */
+const CHARACTER_ESCAPE_BYTES = new Map([
+  ["\\a", 0x07],
+  ["\\b", 0x08],
+  ["\\t", 0x09],
+  ["\\n", 0x0a],
+  ["\\v", 0x0b],
+  ["\\f", 0x0c],
+  ["\\r", 0x0d],
+  ['\\"', 0x22],
+  ["\\\\", 0x5c],
+])
+
+/** The bytes one token stands for, or null for an escape git never writes. */
+const getTokenBytes = (match: RegExpExecArray): Buffer | null => {
+  const literal = match.groups?.literal
+  const octal = match.groups?.octal
+
+  if (literal) return Buffer.from(literal, "utf8")
+  if (octal) return Buffer.of(Number.parseInt(octal, 8))
+
+  const escapeByte = CHARACTER_ESCAPE_BYTES.get(match[0])
+
+  if (!escapeByte) return null
+  return Buffer.of(escapeByte)
+}
+
+/** Decodes a path parse-diff returned with git's quotes removed but its
+ *  escapes kept. Escaped bytes decode as UTF-8. */
+export const decodeQuotedPath = (path: string): QuotedPathDecoding => {
+  // Git quotes any path containing a backslash, whatever core.quotePath says,
+  // and every character it quotes becomes an escape that starts with one. So
+  // a backslash is present exactly when the path was quoted.
+  if (!path.includes("\\")) return { kind: "unquoted" }
+
+  const byteChunks = Array.from(path.matchAll(QUOTED_PATH_TOKEN), getTokenBytes)
+
+  if (byteChunks.includes(null)) return { kind: "malformed", reason: "unrecognized escape" }
+
+  const bytes = Buffer.concat(byteChunks.filter((chunk) => chunk !== null))
+
+  if (!isUtf8(bytes)) return { kind: "malformed", reason: "escaped bytes are not valid UTF-8" }
+  return { kind: "decoded", path: bytes.toString("utf8") }
+}
+
+/**
+ * Decodes the quoted from and to paths of parsed diff files. GitHub's diff
+ * quotes every non-ASCII path and any path with a quote, a backslash, or a
+ * control character. parse-diff keeps the escapes, so without this step the
+ * workspace read, diff exclusion, and inline comments all see a path that
+ * does not exist.
+ */
+export const decodeQuotedFilePaths = (files: ReadonlyArray<File>, logger: Logger): File[] => {
+  const decodePath = (rawPath: string): string => {
+    const decoding = decodeQuotedPath(rawPath)
+
+    if (decoding.kind === "unquoted") return rawPath
+
+    // A guessed decoding would name a file that does not exist. The path as
+    // received is at least the one GitHub's diff shows.
+    if (decoding.kind === "malformed") {
+      logger.warn("malformed quoted diff path — kept as received", {
+        path: rawPath,
+        reason: decoding.reason,
+      })
+      return rawPath
+    }
+
+    logger.debug("decoded quoted diff path", { quotedPath: rawPath, path: decoding.path })
+    return decoding.path
+  }
+
+  return files.map((file) => ({
+    ...file,
+    ...(file.from && { from: decodePath(file.from) }),
+    ...(file.to && { to: decodePath(file.to) }),
+  }))
+}
diff --git a/src/orchestrate.ts b/src/orchestrate.ts
index bb78a6f..2d87857 100644
--- a/src/orchestrate.ts
+++ b/src/orchestrate.ts
@@ -10,6 +10,7 @@ import {
   renderExcludedFilesNote,
   summarizeExclusionSources,
 } from "./diff/exclusion.js"
+import { decodeQuotedFilePaths } from "./diff/quoted-paths.js"
 import { describeError, type Logger } from "./logger.js"
 import type { CheckRunConclusion, CheckRunOutput, GithubClient } from "./github/client.js"
 import { resolvePullRequestEvent, type PrContext } from "./github/event.js"
@@ -560,7 +561,7 @@ const runReviewPipeline = async (
     return postSkipReview({ reason: "diff exceeds GitHub's diff API limits" })
   }
 
-  const files = parseDiff(diffResult.diff)
+  const files = decodeQuotedFilePaths(parseDiff(diffResult.diff), logger)
 
   if (files.length === 0) {
     return postSkipReview({ reason: "empty diff" })

From 0167a9cc4dd59bfb029795d68b7f886fcde4fcbd Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:18:06 -0400
Subject: [PATCH 02/15] fix(review): reject decoded diff paths with control or
 separator characters
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A decoded escape can put a real newline, C1 control, or U+2028/U+2029 into
a path. The path is rendered raw in the annotated diff header and in
markdown, so a filename could forge a header line. Such a path now stays
as received, with a warn log naming the code point.

The job-summary list now escapes backslashes too, so a decoded backslash
before a pipe cannot cancel the pipe's escape.

Ship-Check: pr-review · claude-opus-5-5
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/__tests__/orchestrate.test.ts           | 23 +++++++++
 src/diff/__tests__/quoted-paths.test.ts     | 56 ++++++++++++++++++---
 src/diff/quoted-paths.ts                    | 33 +++++++++---
 src/review/__tests__/review-summary.test.ts |  9 ++++
 src/review/review-summary.ts                |  6 +--
 5 files changed, 108 insertions(+), 19 deletions(-)

diff --git a/src/__tests__/orchestrate.test.ts b/src/__tests__/orchestrate.test.ts
index b8644cf..b4f2889 100644
--- a/src/__tests__/orchestrate.test.ts
+++ b/src/__tests__/orchestrate.test.ts
@@ -1015,6 +1015,29 @@ index 1111111..2222222 100644
       expect(expectedComments.map((comment) => comment.path)).toEqual([decodedPath])
     })
 
+    it("keeps a filename's escaped newline from forging a header line in the annotated diff", async () => {
+      const forgingPathDiff = String.raw`diff --git "a/nl\n=== forged.ts ===.md" "b/nl\n=== forged.ts ===.md"
+index 1111111..2222222 100644
+--- "a/nl\n=== forged.ts ===.md"
++++ "b/nl\n=== forged.ts ===.md"
+@@ -1 +1 @@
+-old line
++new line
+`
+      const stubs = makeOrchestrateDeps({
+        githubClient: {
+          fetchDiff: async () => ({ kind: "ok" as const, diff: forgingPathDiff }),
+        },
+      })
+
+      await orchestrate(stubs.deps, createTestLogger())
+
+      const headerLines = first(stubs.generateFindingsCalls)
+        .annotatedDiff.split("\n")
+        .filter((line) => line.startsWith("=== "))
+      expect(headerLines).toEqual([String.raw`=== nl\n=== forged.ts ===.md ===`])
+    })
+
     it("keeps a priority doc in the rendered prompt when changed files use the rest of the budget", async () => {
       const priorityDocContent = "# Review reference\nCheck API behavior."
       const priorityDocTokens = estimateTokens(priorityDocContent)
diff --git a/src/diff/__tests__/quoted-paths.test.ts b/src/diff/__tests__/quoted-paths.test.ts
index 44b0dc7..35bd724 100644
--- a/src/diff/__tests__/quoted-paths.test.ts
+++ b/src/diff/__tests__/quoted-paths.test.ts
@@ -34,11 +34,6 @@ describe("decodeQuotedPath", () => {
       path: String.raw`back\\slash.md`,
       expected: "back\\slash.md",
     },
-    {
-      label: "a single-character control escape",
-      path: String.raw`tab\there.md`,
-      expected: "tab\there.md",
-    },
     {
       label: "raw non-ASCII text beside an escape",
       path: String.raw`å\\b.md`,
@@ -84,8 +79,35 @@ describe("decodeQuotedPath", () => {
       reason: "escaped bytes are not valid UTF-8",
     },
   ])("rejects $label as malformed", ({ path, reason }) => {
-    expect(decodeQuotedPath(path)).toEqual({ kind: "malformed", reason })
+    expect(decodeQuotedPath(path)).toEqual({ kind: "rejected", reason })
   })
+
+  it.each([
+    { label: "a newline escape", path: String.raw`nl\n=== forged.ts ===.md`, codePoint: "000A" },
+    { label: "a carriage-return escape", path: String.raw`cr\rx.md`, codePoint: "000D" },
+    { label: "a tab escape", path: String.raw`tab\there.md`, codePoint: "0009" },
+    { label: "an octal C0 escape", path: String.raw`soh\001x.md`, codePoint: "0001" },
+    { label: "an octal DEL escape", path: String.raw`del\177x.md`, codePoint: "007F" },
+    { label: "an escaped NEL (U+0085)", path: String.raw`nel\302\205x.md`, codePoint: "0085" },
+    {
+      label: "an escaped line separator (U+2028)",
+      path: String.raw`ls\342\200\250x.md`,
+      codePoint: "2028",
+    },
+    {
+      label: "an escaped paragraph separator (U+2029)",
+      path: String.raw`ps\342\200\251x.md`,
+      codePoint: "2029",
+    },
+  ])(
+    "rejects $label that would decode to a control or separator character",
+    ({ path, codePoint }) => {
+      expect(decodeQuotedPath(path)).toEqual({
+        kind: "rejected",
+        reason: `decoded path contains control or separator character U+${codePoint}`,
+      })
+    },
+  )
 })
 
 describe("decodeQuotedFilePaths", () => {
@@ -164,14 +186,32 @@ rename to "docs/\341\213\265-new.md"`
     expect(logger.messages).toEqual([
       {
         level: "warn",
-        message: "malformed quoted diff path — kept as received",
+        message: "quoted diff path rejected — kept as received",
         data: { path: String.raw`caf\351.md`, reason: "escaped bytes are not valid UTF-8" },
       },
       {
         level: "warn",
-        message: "malformed quoted diff path — kept as received",
+        message: "quoted diff path rejected — kept as received",
         data: { path: String.raw`caf\351.md`, reason: "escaped bytes are not valid UTF-8" },
       },
     ])
   })
+
+  it("keeps a path with an escaped newline as received and warns", () => {
+    const escapedPath = String.raw`nl\n=== forged.ts ===.md`
+    const file = makeFile({ new: true, from: "/dev/null", to: escapedPath })
+    const logger = createTestLogger()
+
+    expect(decodeQuotedFilePaths([file], logger)).toEqual([file])
+    expect(logger.messages).toEqual([
+      {
+        level: "warn",
+        message: "quoted diff path rejected — kept as received",
+        data: {
+          path: escapedPath,
+          reason: "decoded path contains control or separator character U+000A",
+        },
+      },
+    ])
+  })
 })
diff --git a/src/diff/quoted-paths.ts b/src/diff/quoted-paths.ts
index 8f0251f..a4763c0 100644
--- a/src/diff/quoted-paths.ts
+++ b/src/diff/quoted-paths.ts
@@ -3,7 +3,7 @@ import type { File } from "parse-diff"
 import type { Logger } from "../logger.js"
 
 export type QuotedPathDecoding =
-  { kind: "unquoted" } | { kind: "decoded"; path: string } | { kind: "malformed"; reason: string }
+  { kind: "unquoted" } | { kind: "decoded"; path: string } | { kind: "rejected"; reason: string }
 
 /**
  * One token of a path in git's C-style quoting, matching what git's
@@ -28,6 +28,9 @@ const CHARACTER_ESCAPE_BYTES = new Map([
   ["\\\\", 0x5c],
 ])
 
+/** A control character (C0, DEL, C1) or a Unicode line or paragraph separator. */
+const CONTROL_OR_SEPARATOR_CHARACTER = /[\p{Cc}\p{Zl}\p{Zp}]/u
+
 /** The bytes one token stands for, or null for an escape git never writes. */
 const getTokenBytes = (match: RegExpExecArray): Buffer | null => {
   const literal = match.groups?.literal
@@ -52,12 +55,26 @@ export const decodeQuotedPath = (path: string): QuotedPathDecoding => {
 
   const byteChunks = Array.from(path.matchAll(QUOTED_PATH_TOKEN), getTokenBytes)
 
-  if (byteChunks.includes(null)) return { kind: "malformed", reason: "unrecognized escape" }
+  if (byteChunks.includes(null)) return { kind: "rejected", reason: "unrecognized escape" }
 
   const bytes = Buffer.concat(byteChunks.filter((chunk) => chunk !== null))
 
-  if (!isUtf8(bytes)) return { kind: "malformed", reason: "escaped bytes are not valid UTF-8" }
-  return { kind: "decoded", path: bytes.toString("utf8") }
+  if (!isUtf8(bytes)) return { kind: "rejected", reason: "escaped bytes are not valid UTF-8" }
+
+  const decodedPath = bytes.toString("utf8")
+  const unsafeCharacter = CONTROL_OR_SEPARATOR_CHARACTER.exec(decodedPath)?.[0]
+
+  // The path is PR-author-controlled and is rendered raw in the annotated diff
+  // header and in markdown. A decoded newline would let a filename forge a
+  // header line there, while the escaped form breaks no line.
+  if (unsafeCharacter) {
+    const codePoint = unsafeCharacter.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")
+    return {
+      kind: "rejected",
+      reason: `decoded path contains control or separator character U+${codePoint}`,
+    }
+  }
+  return { kind: "decoded", path: decodedPath }
 }
 
 /**
@@ -73,10 +90,10 @@ export const decodeQuotedFilePaths = (files: ReadonlyArray<File>, logger: Logger
 
     if (decoding.kind === "unquoted") return rawPath
 
-    // A guessed decoding would name a file that does not exist. The path as
-    // received is at least the one GitHub's diff shows.
-    if (decoding.kind === "malformed") {
-      logger.warn("malformed quoted diff path — kept as received", {
+    // A guessed decoding would name a file that does not exist, and the escaped
+    // form breaks no line. The path as received is the one GitHub's diff shows.
+    if (decoding.kind === "rejected") {
+      logger.warn("quoted diff path rejected — kept as received", {
         path: rawPath,
         reason: decoding.reason,
       })
diff --git a/src/review/__tests__/review-summary.test.ts b/src/review/__tests__/review-summary.test.ts
index 288d744..a710c2e 100644
--- a/src/review/__tests__/review-summary.test.ts
+++ b/src/review/__tests__/review-summary.test.ts
@@ -337,4 +337,13 @@ describe("renderReviewSummary", () => {
     expect(summary.split("\n")[12]).toBe("| Changed files | 1 | src/a\\|b.ts |")
     expect(summary).not.toContain("| src/a|b.ts |")
   })
+
+  it("escapes a backslash before a pipe so the pipe stays escaped", () => {
+    const summary = renderReviewSummary({
+      ...baseStats,
+      changedFilePaths: [String.raw`src/a\|b.ts`],
+    })
+
+    expect(summary.split("\n")[12]).toBe(String.raw`| Changed files | 1 | src/a\\\|b.ts |`)
+  })
 })
diff --git a/src/review/review-summary.ts b/src/review/review-summary.ts
index a225111..0e89ffe 100644
--- a/src/review/review-summary.ts
+++ b/src/review/review-summary.ts
@@ -39,11 +39,11 @@ export type ReviewSummaryStats = {
 }
 
 /** Comma-joined items for one markdown line or table cell — em-dash when
- *  empty so cells are never blank. Pipes are escaped so an item can't break
- *  a table row. */
+ *  empty so cells are never blank. Backslashes and pipes are escaped, so an
+ *  item's own backslash can't cancel a pipe's escape and break the row. */
 const renderCommaList = (items: string[]): string => {
   if (items.length === 0) return "—"
-  return items.map((item) => item.replaceAll("|", "\\|")).join(", ")
+  return items.map((item) => item.replaceAll("\\", "\\\\").replaceAll("|", "\\|")).join(", ")
 }
 
 /** The conventions file and how much of it reached the model. */

From 0cb933fe5d09322c7e76d376ed2d05c56db2555f Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:28:01 -0400
Subject: [PATCH 03/15] style: clear readability pauses in quoted-path decoding
 and its call sites
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- quoted-paths: document the token regex's optional escaped character, the
  s flag, and full coverage; state the escape map's key form; compare the
  escape byte to undefined since 0x00 is a valid byte; narrow the chunks
  with every() instead of a second null filter; name the annotated diff
  header; say how a rejected path is reviewed.
- orchestrate: state that decoding happens once for every later step,
  describe the excluded-entry shape, drop the no-op normalize on excluded
  paths, correct the comment on when parse-diff leaves `from` undefined,
  and turn the type-only null check into a commented guard.
- review-summary: explain the backslash-then-pipe order with an example,
  document the priority-doc floor and cross-run duplicate fields, and mark
  the remaining truncated status.

Ship-Check: code-quality · claude-opus-5-5
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/diff/quoted-paths.ts     | 38 ++++++++++++++++++++++++------------
 src/orchestrate.ts           | 31 ++++++++++++++++++++---------
 src/review/review-summary.ts |  9 +++++++++
 3 files changed, 57 insertions(+), 21 deletions(-)

diff --git a/src/diff/quoted-paths.ts b/src/diff/quoted-paths.ts
index a4763c0..be61512 100644
--- a/src/diff/quoted-paths.ts
+++ b/src/diff/quoted-paths.ts
@@ -11,11 +11,17 @@ export type QuotedPathDecoding =
  * - literal: a run of characters with no backslash.
  * - octal: three octal digits for one byte. Git writes the first digit as 0-3.
  * - The unnamed last branch takes any other backslash and the character after
- *   it. CHARACTER_ESCAPE_BYTES decides whether that pair is a valid escape.
+ *   it. A backslash at the end of the path matches alone. The s flag lets that
+ *   character be a newline. CHARACTER_ESCAPE_BYTES decides whether the match
+ *   is a valid escape.
+ *
+ * Every character starts one of the three branches, so matchAll consumes the
+ * whole path and skips nothing.
  */
 const QUOTED_PATH_TOKEN = /(?<literal>[^\\]+)|\\(?<octal>[0-3][0-7]{2})|\\.?/gs
 
-/** Git's single-character escapes and the byte each stands for. */
+/** Git's single-character escapes and the byte each stands for. Each key is
+ *  the escape as written in the path, backslash included. */
 const CHARACTER_ESCAPE_BYTES = new Map([
   ["\\a", 0x07],
   ["\\b", 0x08],
@@ -41,7 +47,8 @@ const getTokenBytes = (match: RegExpExecArray): Buffer | null => {
 
   const escapeByte = CHARACTER_ESCAPE_BYTES.get(match[0])
 
-  if (!escapeByte) return null
+  // 0x00 is a valid byte, so only a missing key marks an unrecognized escape
+  if (escapeByte === undefined) return null
   return Buffer.of(escapeByte)
 }
 
@@ -50,30 +57,36 @@ const getTokenBytes = (match: RegExpExecArray): Buffer | null => {
 export const decodeQuotedPath = (path: string): QuotedPathDecoding => {
   // Git quotes any path containing a backslash, whatever core.quotePath says,
   // and every character it quotes becomes an escape that starts with one. So
-  // a backslash is present exactly when the path was quoted.
+  // a backslash is present exactly when the path was quoted. GitHub's diff
+  // also quotes every control and non-ASCII character, so an unquoted path
+  // holds none of the characters the check below rejects.
   if (!path.includes("\\")) return { kind: "unquoted" }
 
   const byteChunks = Array.from(path.matchAll(QUOTED_PATH_TOKEN), getTokenBytes)
 
-  if (byteChunks.includes(null)) return { kind: "rejected", reason: "unrecognized escape" }
+  if (!byteChunks.every((chunk) => chunk !== null)) {
+    return { kind: "rejected", reason: "unrecognized escape" }
+  }
 
-  const bytes = Buffer.concat(byteChunks.filter((chunk) => chunk !== null))
+  const bytes = Buffer.concat(byteChunks)
 
   if (!isUtf8(bytes)) return { kind: "rejected", reason: "escaped bytes are not valid UTF-8" }
 
   const decodedPath = bytes.toString("utf8")
   const unsafeCharacter = CONTROL_OR_SEPARATOR_CHARACTER.exec(decodedPath)?.[0]
 
-  // The path is PR-author-controlled and is rendered raw in the annotated diff
-  // header and in markdown. A decoded newline would let a filename forge a
-  // header line there, while the escaped form breaks no line.
+  // The path is PR-author-controlled and is rendered raw in markdown and in
+  // the "=== path ===" line annotateDiff writes above each file's hunks. A
+  // decoded newline would let a filename forge such a line, while the escaped
+  // form breaks no line.
   if (unsafeCharacter) {
-    const codePoint = unsafeCharacter.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")
+    const codePointHex = unsafeCharacter.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")
     return {
       kind: "rejected",
-      reason: `decoded path contains control or separator character U+${codePoint}`,
+      reason: `decoded path contains control or separator character U+${codePointHex}`,
     }
   }
+
   return { kind: "decoded", path: decodedPath }
 }
 
@@ -91,7 +104,8 @@ export const decodeQuotedFilePaths = (files: ReadonlyArray<File>, logger: Logger
     if (decoding.kind === "unquoted") return rawPath
 
     // A guessed decoding would name a file that does not exist, and the escaped
-    // form breaks no line. The path as received is the one GitHub's diff shows.
+    // form breaks no line, so the path stays as GitHub's diff shows it. The
+    // checkout has no file at that path, so the file is reviewed from its diff alone.
     if (decoding.kind === "rejected") {
       logger.warn("quoted diff path rejected — kept as received", {
         path: rawPath,
diff --git a/src/orchestrate.ts b/src/orchestrate.ts
index 2d87857..76c0426 100644
--- a/src/orchestrate.ts
+++ b/src/orchestrate.ts
@@ -561,6 +561,8 @@ const runReviewPipeline = async (
     return postSkipReview({ reason: "diff exceeds GitHub's diff API limits" })
   }
 
+  // parse-diff keeps git's escapes in quoted paths. Decoding them once here
+  // gives every later step, from exclusion to inline comments, the real path.
   const files = decodeQuotedFilePaths(parseDiff(diffResult.diff), logger)
 
   if (files.length === 0) {
@@ -577,6 +579,10 @@ const runReviewPipeline = async (
     { ...config.diffExcludePaths, gitAttributesContent },
     logger,
   )
+
+  // Each excluded entry is a summary rather than a parse-diff file. Its path is
+  // the new path, or the old path for a deleted file, already posix-normalized
+  // with no leading "/". Its source names the rule that excluded it.
   const { kept: reviewableFiles, excluded: excludedDiffFiles } = partitionExcludedFiles({
     files,
     matcher: exclusionMatcher,
@@ -588,6 +594,7 @@ const runReviewPipeline = async (
       excludedPaths: excludedDiffFiles.map((file) => `${file.path} (${file.source})`).join(", "),
     })
   }
+
   if (reviewableFiles.length === 0) {
     // Reason names the layers that actually excluded (an operator on default
     // inputs never set diff_exclude_paths); the body names every file.
@@ -620,10 +627,10 @@ const runReviewPipeline = async (
   // Diff-excluded files must stay out of every context channel: the trailer
   // told the model their content is not shown, so neither the related-file
   // and doc scans nor the priority-doc read may pull that content back in.
+  // Excluded paths arrive normalized, so only the configured doc paths are
+  // normalized here.
   const diffExcludedPaths = excludedDiffFiles.map((file) => file.path)
-  const diffExcludedPathSet = new Set(
-    diffExcludedPaths.map((excludedPath) => posix.normalize(excludedPath)),
-  )
+  const diffExcludedPathSet = new Set(diffExcludedPaths)
   const reviewablePriorityDocs = config.priorityDocs.filter(
     (docPath) => !diffExcludedPathSet.has(posix.normalize(docPath)),
   )
@@ -634,12 +641,14 @@ const runReviewPipeline = async (
     const toPath = newFilePath(file)
     const fromPath = file.from
 
-    // A deleted file has no new path. Its old path joins the prompt's file
-    // paths through deletedPaths below
-    if (toPath === null) return []
+    // A deleted file has no new path, because parse-diff sets `to` to
+    // "/dev/null" whenever it sets `deleted`. Its old path joins the prompt's
+    // file paths through deletedPaths below
+    if (!toPath) return []
 
-    // parse-diff: from can be undefined for a binary file and is "/dev/null"
-    // for an added file (binary or not) — neither is a pre-rename path worth tracing
+    // parse-diff sets `from` to "/dev/null" for an added file, as it sets `to`
+    // for a deleted one. `from` is undefined only when parse-diff cannot read
+    // the file's diff header. Neither value is a pre-rename path worth tracing
     if (!fromPath || fromPath === "/dev/null" || fromPath === toPath) return [toPath]
 
     return [toPath, fromPath]
@@ -788,10 +797,14 @@ const runReviewPipeline = async (
   // diff has no hunks, so it carries nothing.
   const conventionsAddedInDiff = reviewableFiles.some((file) => {
     const toPath = newFilePath(file)
+
+    // Every added file has a new path, so this check skips no added file. It
+    // narrows toPath's type for the comparison below.
+    if (!toPath) return false
+
     return (
       Boolean(file.new) &&
       file.chunks.length > 0 &&
-      toPath !== null &&
       posix.normalize(toPath) === posix.normalize(config.conventionsFile)
     )
   })
diff --git a/src/review/review-summary.ts b/src/review/review-summary.ts
index 0e89ffe..78b2e9b 100644
--- a/src/review/review-summary.ts
+++ b/src/review/review-summary.ts
@@ -23,6 +23,8 @@ export type ReviewSummaryStats = {
   docsExcludedPaths: string[]
   tokenBudgetTotal: number
   tokenBudgetUsedByDiff: number
+  /** Tokens reserved for priority docs: what the early priority-doc read spent
+   *  plus what was held back from related files. */
   tokenBudgetPriorityDocFloor: number
   tokenBudgetRemainingForDocs: number
   totalFromModel: number
@@ -31,6 +33,7 @@ export type ReviewSummaryStats = {
   droppedAsUnknownFile: number
   /** Findings two phases reported on overlapping lines of one file. */
   duplicatesAcrossPhases: number
+  /** Findings dropped because an earlier run already posted them. */
   duplicatesRemoved: number
   droppedBelowThreshold: number
   droppedAsOverlapping: number
@@ -43,6 +46,10 @@ export type ReviewSummaryStats = {
  *  item's own backslash can't cancel a pipe's escape and break the row. */
 const renderCommaList = (items: string[]): string => {
   if (items.length === 0) return "—"
+
+  // Backslashes are escaped first. Escaping pipes first would double each
+  // pipe escape's own backslash and leave the pipe bare. For example, `a\|b`
+  // renders as `a\\\|b`.
   return items.map((item) => item.replaceAll("\\", "\\\\").replaceAll("|", "\\|")).join(", ")
 }
 
@@ -52,12 +59,14 @@ const renderConventionsCoverage = ({
   conventionsCoverage,
 }: Pick<ReviewSummaryStats, "conventionsFile" | "conventionsCoverage">): string => {
   if (conventionsCoverage.status === "not-found") return "none"
+
   // The size against the cap shows how close a fitting file is to truncating
   if (conventionsCoverage.status === "full") {
     const { characterCap, totalCharacters } = conventionsCoverage
     return `${conventionsFile} (${totalCharacters} characters, within the ${characterCap}-character cap)`
   }
 
+  // Only the truncated status remains
   const { fullCopyChannel, characterCap, totalCharacters } = conventionsCoverage
 
   // A priority-doc copy replaces the truncated section, so no head was sent

From dcbbb1dbdd01bfdc9bbc959d96e011cd6c1d0cc6 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:33:09 -0400
Subject: [PATCH 04/15] test: pin escape edge cases and normalized excluded
 paths
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds decoder cases for an escaped backslash beside octal escapes, an
escaped backslash followed by octal-looking digits, a NUL octal escape,
and the bell, backspace, vertical-tab, and form-feed escapes. Adds an
orchestrate case where a diff path with a doubled slash is excluded and
still matches its priority doc and the scan exclusions.

Ship-Check: test-audit · claude-opus-5-5
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/__tests__/orchestrate.test.ts       | 37 +++++++++++++++++++++++++
 src/diff/__tests__/quoted-paths.test.ts | 16 +++++++++++
 2 files changed, 53 insertions(+)

diff --git a/src/__tests__/orchestrate.test.ts b/src/__tests__/orchestrate.test.ts
index b4f2889..428b916 100644
--- a/src/__tests__/orchestrate.test.ts
+++ b/src/__tests__/orchestrate.test.ts
@@ -778,6 +778,43 @@ describe("orchestrate", () => {
       expect(first(stubs.findRelatedDocsCalls).excludePaths).toEqual(["assets/logo.png"])
     })
 
+    it("normalizes a doubled-slash excluded diff path before matching priority docs and scan exclusions", async () => {
+      // Orchestrate compares excluded paths to priority docs as received, so
+      // this fails if partitioning ever stops normalizing them
+      const unnormalizedPathDiff = `diff --git a/assets//guide.md b/assets//guide.md
+index 1111111..2222222 100644
+--- a/assets//guide.md
++++ b/assets//guide.md
+@@ -1 +1 @@
+-old guide
++new guide
+diff --git a/src/app.ts b/src/app.ts
+index 3333333..4444444 100644
+--- a/src/app.ts
++++ b/src/app.ts
+@@ -1 +1 @@
+-old line
++new line
+`
+      const stubs = makeOrchestrateDeps({
+        githubClient: {
+          fetchDiff: async () => ({ kind: "ok" as const, diff: unnormalizedPathDiff }),
+        },
+        config: {
+          priorityDocs: ["assets/guide.md", "docs/guide.md"],
+          diffExcludePaths: {
+            defaultPatterns: [],
+            diffExcludePathPatterns: ["assets/**"],
+          },
+        },
+      })
+
+      await orchestrate(stubs.deps, createTestLogger())
+
+      expect(first(stubs.readPriorityDocsCalls).priorityDocs).toEqual(["docs/guide.md"])
+      expect(first(stubs.findRelatedFilesCalls).excludePaths).toEqual(["assets/guide.md"])
+    })
+
     it("passes the budget check when the oversized files are all excluded", async () => {
       // Budget 220 (half = 110) fails against the full fixture diff (341
       // tokens); with every src/ file excluded only the binary asset header
diff --git a/src/diff/__tests__/quoted-paths.test.ts b/src/diff/__tests__/quoted-paths.test.ts
index 35bd724..afa293b 100644
--- a/src/diff/__tests__/quoted-paths.test.ts
+++ b/src/diff/__tests__/quoted-paths.test.ts
@@ -39,6 +39,17 @@ describe("decodeQuotedPath", () => {
       path: String.raw`å\\b.md`,
       expected: "å\\b.md",
     },
+    {
+      label: "an escaped backslash directly before octal escapes",
+      path: String.raw`x\\\303\245.md`,
+      expected: "x\\å.md",
+    },
+    {
+      // The two backslashes form one escape, so the "303" after them is literal text
+      label: "an escaped backslash followed by octal-looking digits",
+      path: String.raw`x\\303.md`,
+      expected: "x\\303.md",
+    },
   ])("decodes $label", ({ path, expected }) => {
     expect(decodeQuotedPath(path)).toEqual({ kind: "decoded", path: expected })
   })
@@ -86,6 +97,11 @@ describe("decodeQuotedPath", () => {
     { label: "a newline escape", path: String.raw`nl\n=== forged.ts ===.md`, codePoint: "000A" },
     { label: "a carriage-return escape", path: String.raw`cr\rx.md`, codePoint: "000D" },
     { label: "a tab escape", path: String.raw`tab\there.md`, codePoint: "0009" },
+    { label: "a bell escape", path: String.raw`bel\ax.md`, codePoint: "0007" },
+    { label: "a backspace escape", path: String.raw`bs\bx.md`, codePoint: "0008" },
+    { label: "a vertical-tab escape", path: String.raw`vt\vx.md`, codePoint: "000B" },
+    { label: "a form-feed escape", path: String.raw`ff\fx.md`, codePoint: "000C" },
+    { label: "an octal NUL escape", path: String.raw`nul\000x.md`, codePoint: "0000" },
     { label: "an octal C0 escape", path: String.raw`soh\001x.md`, codePoint: "0001" },
     { label: "an octal DEL escape", path: String.raw`del\177x.md`, codePoint: "007F" },
     { label: "an escaped NEL (U+0085)", path: String.raw`nel\302\205x.md`, codePoint: "0085" },

From 024e98bf24e4a7a5d575c6015a7df8765315b032 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:40:59 -0400
Subject: [PATCH 05/15] fix: decode a quoted diff path that ends in a backslash
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

parse-diff strips a trailing `\"` from `---`/`+++` paths as the closing
quote, so a quoted path ending in an escaped backslash arrived with a lone
trailing backslash. The decoder rejected it and kept a path that names no
file, while the same file in a hunk-less diff decoded correctly from the
`diff --git` line. A lone backslash can only match at the end of the path,
so it now decodes as the escaped backslash parse-diff dropped.

Ship-Check: bug-check · claude-opus-5-5
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/diff/__tests__/quoted-paths.test.ts | 44 +++++++++++++++++++++----
 src/diff/quoted-paths.ts                | 10 ++++--
 2 files changed, 46 insertions(+), 8 deletions(-)

diff --git a/src/diff/__tests__/quoted-paths.test.ts b/src/diff/__tests__/quoted-paths.test.ts
index afa293b..abd6082 100644
--- a/src/diff/__tests__/quoted-paths.test.ts
+++ b/src/diff/__tests__/quoted-paths.test.ts
@@ -50,6 +50,17 @@ describe("decodeQuotedPath", () => {
       path: String.raw`x\\303.md`,
       expected: "x\\303.md",
     },
+    {
+      // parse-diff drops the second backslash of a quoted path's final escaped backslash
+      label: "a lone trailing backslash as an escaped backslash",
+      path: "dir\\\\sub\\\\ends-with\\",
+      expected: "dir\\sub\\ends-with\\",
+    },
+    {
+      label: "an escaped backslash before a lone trailing backslash",
+      path: "two\\\\\\",
+      expected: "two\\\\",
+    },
   ])("decodes $label", ({ path, expected }) => {
     expect(decodeQuotedPath(path)).toEqual({ kind: "decoded", path: expected })
   })
@@ -63,12 +74,6 @@ describe("decodeQuotedPath", () => {
   })
 
   it.each([
-    {
-      // parse-diff drops the escaped backslash of a quoted path that ends in one
-      label: "a lone trailing backslash",
-      path: "ends-with\\",
-      reason: "unrecognized escape",
-    },
     {
       label: "an unknown escape character",
       path: String.raw`bad\x.md`,
@@ -140,6 +145,33 @@ rename to "docs/\341\213\265-new.md"`
     ])
   })
 
+  it("decodes a path ending in a backslash from both diff header forms", () => {
+    const quotedPath = "dir\\\\sub\\\\"
+    const editedFileDiff = [
+      `diff --git "a/${quotedPath}" "b/${quotedPath}"`,
+      "index 1111111..2222222 100644",
+      `--- "a/${quotedPath}"`,
+      `+++ "b/${quotedPath}"`,
+      "@@ -1 +1 @@",
+      "-old",
+      "+new",
+    ].join("\n")
+    const renamedFileDiff = [
+      `diff --git "a/${quotedPath}" "b/${quotedPath}x"`,
+      "similarity index 100%",
+    ].join("\n")
+
+    const decodedPaths = decodeQuotedFilePaths(
+      parseDiff(`${editedFileDiff}\n${renamedFileDiff}`),
+      createTestLogger(),
+    ).map(({ from, to }) => ({ from, to }))
+
+    expect(decodedPaths).toEqual([
+      { from: "dir\\sub\\", to: "dir\\sub\\" },
+      { from: "dir\\sub\\", to: "dir\\sub\\x" },
+    ])
+  })
+
   it("decodes an added file and keeps its /dev/null old path", () => {
     const file = makeFile({ new: true, from: "/dev/null", to: String.raw`\303\245.md` })
 
diff --git a/src/diff/quoted-paths.ts b/src/diff/quoted-paths.ts
index be61512..80b94cc 100644
--- a/src/diff/quoted-paths.ts
+++ b/src/diff/quoted-paths.ts
@@ -12,8 +12,8 @@ export type QuotedPathDecoding =
  * - octal: three octal digits for one byte. Git writes the first digit as 0-3.
  * - The unnamed last branch takes any other backslash and the character after
  *   it. A backslash at the end of the path matches alone. The s flag lets that
- *   character be a newline. CHARACTER_ESCAPE_BYTES decides whether the match
- *   is a valid escape.
+ *   character be a newline. CHARACTER_ESCAPE_BYTES decides whether a
+ *   two-character match is a valid escape.
  *
  * Every character starts one of the three branches, so matchAll consumes the
  * whole path and skips nothing.
@@ -45,6 +45,12 @@ const getTokenBytes = (match: RegExpExecArray): Buffer | null => {
   if (literal) return Buffer.from(literal, "utf8")
   if (octal) return Buffer.of(Number.parseInt(octal, 8))
 
+  // parse-diff's `---` and `+++` parsing strips a trailing `\"` as the closing
+  // quote, so a path ending in an escaped backslash arrives with only its first
+  // backslash. A lone backslash can only match at the end of the path, and it
+  // stands for that escaped backslash.
+  if (match[0] === "\\") return Buffer.of(0x5c)
+
   const escapeByte = CHARACTER_ESCAPE_BYTES.get(match[0])
 
   // 0x00 is a valid byte, so only a missing key marks an unrecognized escape

From 0fda509ccf6d3ff737673ebc0b8bc22c48e1185e Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:51:17 -0400
Subject: [PATCH 06/15] fix: post findings on a rejected diff path as
 standalone comments
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A quoted diff path whose decoding is rejected keeps git's escapes, so it
names no file GitHub knows. An inline comment on it made GitHub reject the
whole review and reroute every inline finding to issue comments.

decodeQuotedFilePaths now returns the rejected paths beside the files, and
the orchestrator leaves those files out of the commentable-lines map. Their
findings post as standalone comments while the rest of the review still
posts inline. The file stays in the diff and the prompt.

Ship-Check: triage · claude-opus-5-5
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/__tests__/orchestrate.test.ts       | 66 +++++++++++++++++++++++++
 src/diff/__tests__/quoted-paths.test.ts | 55 +++++++++++++++------
 src/diff/quoted-paths.ts                | 58 +++++++++++++++++-----
 src/orchestrate.ts                      | 19 ++++++-
 4 files changed, 167 insertions(+), 31 deletions(-)

diff --git a/src/__tests__/orchestrate.test.ts b/src/__tests__/orchestrate.test.ts
index 428b916..653c1c4 100644
--- a/src/__tests__/orchestrate.test.ts
+++ b/src/__tests__/orchestrate.test.ts
@@ -1075,6 +1075,72 @@ index 1111111..2222222 100644
       expect(headerLines).toEqual([String.raw`=== nl\n=== forged.ts ===.md ===`])
     })
 
+    it("posts a finding on a rejected quoted path as a standalone comment and keeps the rest inline", async () => {
+      const escapedPath = String.raw`a\tb.ts`
+      const mixedPathDiff = String.raw`diff --git a/src/app.ts b/src/app.ts
+index 1111111..2222222 100644
+--- a/src/app.ts
++++ b/src/app.ts
+@@ -1 +1 @@
+-old app line
++new app line
+diff --git "a/a\tb.ts" "b/a\tb.ts"
+index 3333333..4444444 100644
+--- "a/a\tb.ts"
++++ "b/a\tb.ts"
+@@ -1 +1 @@
+-old tab line
++new tab line
+`
+      const normalFinding = makeFinding({ file: "src/app.ts", line: 1, title: "App line bug" })
+      const rejectedPathFinding = makeFinding({ file: escapedPath, line: 1, title: "Tab bug" })
+      const stubs = makeOrchestrateDeps({
+        githubClient: {
+          fetchDiff: async () => ({ kind: "ok" as const, diff: mixedPathDiff }),
+        },
+        fixtureResult: {
+          review: { analysis: "checked", findings: [normalFinding, rejectedPathFinding] },
+        },
+      })
+      const logger = createTestLogger()
+
+      await orchestrate(stubs.deps, logger)
+
+      const expectedComments = mapFindingsToReview({
+        findings: [withRoutedModel(normalFinding, "test/model")],
+        commentableByPath: new Map([
+          ["src/app.ts", { rightLines: new Set([1]), hunkRanges: [{ start: 1, end: 1 }] }],
+        ]),
+      }).comments
+      expect(stubs.postFindingsReviewCalls).toEqual([
+        {
+          prNumber: 7,
+          commitId: fixturePrContext.headSha,
+          body: REVIEW_MARKER,
+          comments: expectedComments,
+        },
+      ])
+      expect(expectedComments.map((comment) => comment.path)).toEqual(["src/app.ts"])
+      expect(stubs.postIssueCommentCalls).toEqual([
+        {
+          prNumber: 7,
+          body: renderBeyondDiffFinding(withRoutedModel(rejectedPathFinding, "test/model")),
+        },
+      ])
+      expect(
+        logsWithMessage(
+          logger,
+          "file left out of inline comments because its diff path was rejected",
+        ),
+      ).toEqual([
+        {
+          level: "debug",
+          message: "file left out of inline comments because its diff path was rejected",
+          data: { path: escapedPath },
+        },
+      ])
+    })
+
     it("keeps a priority doc in the rendered prompt when changed files use the rest of the budget", async () => {
       const priorityDocContent = "# Review reference\nCheck API behavior."
       const priorityDocTokens = estimateTokens(priorityDocContent)
diff --git a/src/diff/__tests__/quoted-paths.test.ts b/src/diff/__tests__/quoted-paths.test.ts
index abd6082..c8e780c 100644
--- a/src/diff/__tests__/quoted-paths.test.ts
+++ b/src/diff/__tests__/quoted-paths.test.ts
@@ -140,9 +140,10 @@ rename to "docs/\341\213\265-new.md"`
 
     const decoded = decodeQuotedFilePaths(parseDiff(renameDiff), createTestLogger())
 
-    expect(decoded).toEqual([
-      { chunks: [], additions: 0, deletions: 0, from: "docs/ድ.md", to: "docs/ድ-new.md" },
-    ])
+    expect(decoded).toEqual({
+      files: [{ chunks: [], additions: 0, deletions: 0, from: "docs/ድ.md", to: "docs/ድ-new.md" }],
+      rejectedPaths: new Set(),
+    })
   })
 
   it("decodes a path ending in a backslash from both diff header forms", () => {
@@ -164,7 +165,7 @@ rename to "docs/\341\213\265-new.md"`
     const decodedPaths = decodeQuotedFilePaths(
       parseDiff(`${editedFileDiff}\n${renamedFileDiff}`),
       createTestLogger(),
-    ).map(({ from, to }) => ({ from, to }))
+    ).files.map(({ from, to }) => ({ from, to }))
 
     expect(decodedPaths).toEqual([
       { from: "dir\\sub\\", to: "dir\\sub\\" },
@@ -175,32 +176,38 @@ rename to "docs/\341\213\265-new.md"`
   it("decodes an added file and keeps its /dev/null old path", () => {
     const file = makeFile({ new: true, from: "/dev/null", to: String.raw`\303\245.md` })
 
-    expect(decodeQuotedFilePaths([file], createTestLogger())).toEqual([
-      { ...file, from: "/dev/null", to: "å.md" },
-    ])
+    expect(decodeQuotedFilePaths([file], createTestLogger())).toEqual({
+      files: [{ ...file, from: "/dev/null", to: "å.md" }],
+      rejectedPaths: new Set(),
+    })
   })
 
   it("decodes a deleted file and keeps its /dev/null new path", () => {
     const file = makeFile({ deleted: true, from: String.raw`\303\245.md`, to: "/dev/null" })
 
-    expect(decodeQuotedFilePaths([file], createTestLogger())).toEqual([
-      { ...file, from: "å.md", to: "/dev/null" },
-    ])
+    expect(decodeQuotedFilePaths([file], createTestLogger())).toEqual({
+      files: [{ ...file, from: "å.md", to: "/dev/null" }],
+      rejectedPaths: new Set(),
+    })
   })
 
   it("leaves an absent old path absent", () => {
     const file: File = { chunks: [], additions: 0, deletions: 0, to: String.raw`\303\245.png` }
 
-    expect(decodeQuotedFilePaths([file], createTestLogger())).toStrictEqual([
-      { chunks: [], additions: 0, deletions: 0, to: "å.png" },
-    ])
+    expect(decodeQuotedFilePaths([file], createTestLogger())).toStrictEqual({
+      files: [{ chunks: [], additions: 0, deletions: 0, to: "å.png" }],
+      rejectedPaths: new Set(),
+    })
   })
 
   it("returns unquoted files unchanged without logging", () => {
     const file = makeFile()
     const logger = createTestLogger()
 
-    expect(decodeQuotedFilePaths([file], logger)).toEqual([file])
+    expect(decodeQuotedFilePaths([file], logger)).toEqual({
+      files: [file],
+      rejectedPaths: new Set(),
+    })
     expect(logger.messages).toEqual([])
   })
 
@@ -230,7 +237,10 @@ rename to "docs/\341\213\265-new.md"`
     const file = makeFile({ from: String.raw`caf\351.md`, to: String.raw`caf\351.md` })
     const logger = createTestLogger()
 
-    expect(decodeQuotedFilePaths([file], logger)).toEqual([file])
+    expect(decodeQuotedFilePaths([file], logger)).toEqual({
+      files: [file],
+      rejectedPaths: new Set([String.raw`caf\351.md`]),
+    })
     expect(logger.messages).toEqual([
       {
         level: "warn",
@@ -250,7 +260,10 @@ rename to "docs/\341\213\265-new.md"`
     const file = makeFile({ new: true, from: "/dev/null", to: escapedPath })
     const logger = createTestLogger()
 
-    expect(decodeQuotedFilePaths([file], logger)).toEqual([file])
+    expect(decodeQuotedFilePaths([file], logger)).toEqual({
+      files: [file],
+      rejectedPaths: new Set([escapedPath]),
+    })
     expect(logger.messages).toEqual([
       {
         level: "warn",
@@ -262,4 +275,14 @@ rename to "docs/\341\213\265-new.md"`
       },
     ])
   })
+
+  it("reports only the rejected path of a rename whose new path decodes", () => {
+    const rejectedOldPath = String.raw`old\tname.md`
+    const file = makeFile({ from: rejectedOldPath, to: String.raw`\303\245.md` })
+
+    expect(decodeQuotedFilePaths([file], createTestLogger())).toEqual({
+      files: [{ ...file, from: rejectedOldPath, to: "å.md" }],
+      rejectedPaths: new Set([rejectedOldPath]),
+    })
+  })
 })
diff --git a/src/diff/quoted-paths.ts b/src/diff/quoted-paths.ts
index 80b94cc..e03a651 100644
--- a/src/diff/quoted-paths.ts
+++ b/src/diff/quoted-paths.ts
@@ -96,6 +96,13 @@ export const decodeQuotedPath = (path: string): QuotedPathDecoding => {
   return { kind: "decoded", path: decodedPath }
 }
 
+export type DecodedDiffFiles = {
+  files: File[]
+  /** Paths whose decoding was rejected. Each stays in its escaped spelling and
+   *  names no file in the checkout or on GitHub. */
+  rejectedPaths: ReadonlySet<string>
+}
+
 /**
  * Decodes the quoted from and to paths of parsed diff files. GitHub's diff
  * quotes every non-ASCII path and any path with a quote, a backslash, or a
@@ -103,30 +110,55 @@ export const decodeQuotedPath = (path: string): QuotedPathDecoding => {
  * workspace read, diff exclusion, and inline comments all see a path that
  * does not exist.
  */
-export const decodeQuotedFilePaths = (files: ReadonlyArray<File>, logger: Logger): File[] => {
-  const decodePath = (rawPath: string): string => {
+export const decodeQuotedFilePaths = (
+  files: ReadonlyArray<File>,
+  logger: Logger,
+): DecodedDiffFiles => {
+  const decodePath = (rawPath: string): QuotedPathDecoding => {
     const decoding = decodeQuotedPath(rawPath)
 
-    if (decoding.kind === "unquoted") return rawPath
-
     // A guessed decoding would name a file that does not exist, and the escaped
     // form breaks no line, so the path stays as GitHub's diff shows it. The
-    // checkout has no file at that path, so the file is reviewed from its diff alone.
+    // checkout has no file at that path, so the file is reviewed from its diff
+    // alone. GitHub rejects a whole review when one inline comment names that
+    // path, so the caller keeps the file out of inline comments.
     if (decoding.kind === "rejected") {
       logger.warn("quoted diff path rejected — kept as received", {
         path: rawPath,
         reason: decoding.reason,
       })
-      return rawPath
     }
 
-    logger.debug("decoded quoted diff path", { quotedPath: rawPath, path: decoding.path })
-    return decoding.path
+    if (decoding.kind === "decoded") {
+      logger.debug("decoded quoted diff path", { quotedPath: rawPath, path: decoding.path })
+    }
+
+    return decoding
   }
 
-  return files.map((file) => ({
-    ...file,
-    ...(file.from && { from: decodePath(file.from) }),
-    ...(file.to && { to: decodePath(file.to) }),
-  }))
+  const rawPaths = files
+    .flatMap((file) => [file.from, file.to])
+    .filter((rawPath) => rawPath !== undefined)
+  const decodingByRawPath = new Map(
+    rawPaths.map((rawPath): [string, QuotedPathDecoding] => [rawPath, decodePath(rawPath)]),
+  )
+
+  /** The decoded path, or the path as received when it was unquoted or rejected. */
+  const getResolvedPath = (rawPath: string): string => {
+    const decoding = decodingByRawPath.get(rawPath)
+    return decoding?.kind === "decoded" ? decoding.path : rawPath
+  }
+
+  const isRejectedPath = (rawPath: string): boolean => {
+    return decodingByRawPath.get(rawPath)?.kind === "rejected"
+  }
+
+  return {
+    files: files.map((file) => ({
+      ...file,
+      ...(file.from && { from: getResolvedPath(file.from) }),
+      ...(file.to && { to: getResolvedPath(file.to) }),
+    })),
+    rejectedPaths: new Set(rawPaths.filter(isRejectedPath)),
+  }
 }
diff --git a/src/orchestrate.ts b/src/orchestrate.ts
index 76c0426..fdd79f7 100644
--- a/src/orchestrate.ts
+++ b/src/orchestrate.ts
@@ -563,7 +563,7 @@ const runReviewPipeline = async (
 
   // parse-diff keeps git's escapes in quoted paths. Decoding them once here
   // gives every later step, from exclusion to inline comments, the real path.
-  const files = decodeQuotedFilePaths(parseDiff(diffResult.diff), logger)
+  const { files, rejectedPaths } = decodeQuotedFilePaths(parseDiff(diffResult.diff), logger)
 
   if (files.length === 0) {
     return postSkipReview({ reason: "empty diff" })
@@ -622,7 +622,22 @@ const runReviewPipeline = async (
     })
   }
 
-  const commentableByPath = computeCommentableLines(reviewableFiles)
+  // A rejected path keeps git's escapes, so it names no file GitHub knows.
+  // GitHub fails the whole review when one inline comment names such a path,
+  // so the file gets no commentable lines and its findings post as standalone
+  // comments.
+  const diffCommentableByPath = computeCommentableLines(reviewableFiles)
+  const commentableByPath = new Map(
+    Array.from(diffCommentableByPath).filter(([path]) => !rejectedPaths.has(path)),
+  )
+
+  for (const path of diffCommentableByPath.keys()) {
+    if (rejectedPaths.has(path)) {
+      logger.debug("file left out of inline comments because its diff path was rejected", {
+        path,
+      })
+    }
+  }
 
   // Diff-excluded files must stay out of every context channel: the trailer
   // told the model their content is not shown, so neither the related-file

From 1f16ad9db08fe0cf5393a2efd8fc27371fc2765a Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:56:26 -0400
Subject: [PATCH 07/15] fix(diff): reject only line breaks in diff paths, on
 every path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A decoded path is now rejected only when it holds a line break: LF, VT,
FF, CR, NEL, U+2028, or U+2029. Those are the characters that can forge
an annotated-diff header line or split a markdown row. A file named
with a tab or another control character now decodes, so it gets its
workspace read and inline comments. The check also runs on unquoted
paths, so the guard no longer depends on GitHub quoting every line break.

Ship-Check: pr-monitor · claude-opus-5-5
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/__tests__/orchestrate.test.ts       | 18 +++++---
 src/diff/__tests__/quoted-paths.test.ts | 52 ++++++++++++++--------
 src/diff/quoted-paths.ts                | 58 +++++++++++++++----------
 src/orchestrate.ts                      |  8 ++--
 4 files changed, 84 insertions(+), 52 deletions(-)

diff --git a/src/__tests__/orchestrate.test.ts b/src/__tests__/orchestrate.test.ts
index 653c1c4..79435ea 100644
--- a/src/__tests__/orchestrate.test.ts
+++ b/src/__tests__/orchestrate.test.ts
@@ -1076,7 +1076,7 @@ index 1111111..2222222 100644
     })
 
     it("posts a finding on a rejected quoted path as a standalone comment and keeps the rest inline", async () => {
-      const escapedPath = String.raw`a\tb.ts`
+      const escapedPath = String.raw`a\rb.ts`
       const mixedPathDiff = String.raw`diff --git a/src/app.ts b/src/app.ts
 index 1111111..2222222 100644
 --- a/src/app.ts
@@ -1084,16 +1084,20 @@ index 1111111..2222222 100644
 @@ -1 +1 @@
 -old app line
 +new app line
-diff --git "a/a\tb.ts" "b/a\tb.ts"
+diff --git "a/a\rb.ts" "b/a\rb.ts"
 index 3333333..4444444 100644
---- "a/a\tb.ts"
-+++ "b/a\tb.ts"
+--- "a/a\rb.ts"
++++ "b/a\rb.ts"
 @@ -1 +1 @@
--old tab line
-+new tab line
+-old carriage-return line
++new carriage-return line
 `
       const normalFinding = makeFinding({ file: "src/app.ts", line: 1, title: "App line bug" })
-      const rejectedPathFinding = makeFinding({ file: escapedPath, line: 1, title: "Tab bug" })
+      const rejectedPathFinding = makeFinding({
+        file: escapedPath,
+        line: 1,
+        title: "Carriage-return bug",
+      })
       const stubs = makeOrchestrateDeps({
         githubClient: {
           fetchDiff: async () => ({ kind: "ok" as const, diff: mixedPathDiff }),
diff --git a/src/diff/__tests__/quoted-paths.test.ts b/src/diff/__tests__/quoted-paths.test.ts
index c8e780c..8404b55 100644
--- a/src/diff/__tests__/quoted-paths.test.ts
+++ b/src/diff/__tests__/quoted-paths.test.ts
@@ -65,6 +65,17 @@ describe("decodeQuotedPath", () => {
     expect(decodeQuotedPath(path)).toEqual({ kind: "decoded", path: expected })
   })
 
+  it.each([
+    { label: "a tab escape", path: String.raw`notes\told.md`, expected: "notes\told.md" },
+    { label: "a bell escape", path: String.raw`bel\ax.md`, expected: "bel\x07x.md" },
+    { label: "a backspace escape", path: String.raw`bs\bx.md`, expected: "bs\x08x.md" },
+    { label: "an octal NUL escape", path: String.raw`nul\000x.md`, expected: "nul\x00x.md" },
+    { label: "an octal ESC escape", path: String.raw`esc\033x.md`, expected: "esc\x1bx.md" },
+    { label: "an octal DEL escape", path: String.raw`del\177x.md`, expected: "del\x7fx.md" },
+  ])("decodes $label, a control character that breaks no line", ({ path, expected }) => {
+    expect(decodeQuotedPath(path)).toEqual({ kind: "decoded", path: expected })
+  })
+
   it.each([
     { label: "a plain path", path: "src/app.ts" },
     { label: "a path with spaces", path: "docs/plain space.md" },
@@ -101,14 +112,8 @@ describe("decodeQuotedPath", () => {
   it.each([
     { label: "a newline escape", path: String.raw`nl\n=== forged.ts ===.md`, codePoint: "000A" },
     { label: "a carriage-return escape", path: String.raw`cr\rx.md`, codePoint: "000D" },
-    { label: "a tab escape", path: String.raw`tab\there.md`, codePoint: "0009" },
-    { label: "a bell escape", path: String.raw`bel\ax.md`, codePoint: "0007" },
-    { label: "a backspace escape", path: String.raw`bs\bx.md`, codePoint: "0008" },
     { label: "a vertical-tab escape", path: String.raw`vt\vx.md`, codePoint: "000B" },
     { label: "a form-feed escape", path: String.raw`ff\fx.md`, codePoint: "000C" },
-    { label: "an octal NUL escape", path: String.raw`nul\000x.md`, codePoint: "0000" },
-    { label: "an octal C0 escape", path: String.raw`soh\001x.md`, codePoint: "0001" },
-    { label: "an octal DEL escape", path: String.raw`del\177x.md`, codePoint: "007F" },
     { label: "an escaped NEL (U+0085)", path: String.raw`nel\302\205x.md`, codePoint: "0085" },
     {
       label: "an escaped line separator (U+2028)",
@@ -120,15 +125,19 @@ describe("decodeQuotedPath", () => {
       path: String.raw`ps\342\200\251x.md`,
       codePoint: "2029",
     },
-  ])(
-    "rejects $label that would decode to a control or separator character",
-    ({ path, codePoint }) => {
-      expect(decodeQuotedPath(path)).toEqual({
-        kind: "rejected",
-        reason: `decoded path contains control or separator character U+${codePoint}`,
-      })
-    },
-  )
+  ])("rejects $label that would decode to a line break", ({ path, codePoint }) => {
+    expect(decodeQuotedPath(path)).toEqual({
+      kind: "rejected",
+      reason: `path contains line-break character U+${codePoint}`,
+    })
+  })
+
+  it("rejects an unquoted path that holds a raw line separator (U+2028)", () => {
+    expect(decodeQuotedPath("ls\u2028x.md")).toEqual({
+      kind: "rejected",
+      reason: "path contains line-break character U+2028",
+    })
+  })
 })
 
 describe("decodeQuotedFilePaths", () => {
@@ -200,6 +209,15 @@ rename to "docs/\341\213\265-new.md"`
     })
   })
 
+  it("leaves an absent new path absent", () => {
+    const file: File = { chunks: [], additions: 0, deletions: 0, from: String.raw`\303\245.png` }
+
+    expect(decodeQuotedFilePaths([file], createTestLogger())).toStrictEqual({
+      files: [{ chunks: [], additions: 0, deletions: 0, from: "å.png" }],
+      rejectedPaths: new Set(),
+    })
+  })
+
   it("returns unquoted files unchanged without logging", () => {
     const file = makeFile()
     const logger = createTestLogger()
@@ -270,14 +288,14 @@ rename to "docs/\341\213\265-new.md"`
         message: "quoted diff path rejected — kept as received",
         data: {
           path: escapedPath,
-          reason: "decoded path contains control or separator character U+000A",
+          reason: "path contains line-break character U+000A",
         },
       },
     ])
   })
 
   it("reports only the rejected path of a rename whose new path decodes", () => {
-    const rejectedOldPath = String.raw`old\tname.md`
+    const rejectedOldPath = String.raw`old\rname.md`
     const file = makeFile({ from: rejectedOldPath, to: String.raw`\303\245.md` })
 
     expect(decodeQuotedFilePaths([file], createTestLogger())).toEqual({
diff --git a/src/diff/quoted-paths.ts b/src/diff/quoted-paths.ts
index e03a651..d03d43b 100644
--- a/src/diff/quoted-paths.ts
+++ b/src/diff/quoted-paths.ts
@@ -34,8 +34,9 @@ const CHARACTER_ESCAPE_BYTES = new Map([
   ["\\\\", 0x5c],
 ])
 
-/** A control character (C0, DEL, C1) or a Unicode line or paragraph separator. */
-const CONTROL_OR_SEPARATOR_CHARACTER = /[\p{Cc}\p{Zl}\p{Zp}]/u
+/** A character that ends a line: LF, VT, FF, CR, NEL (U+0085), or a Unicode
+ *  line or paragraph separator (U+2028, U+2029). */
+const LINE_BREAK_CHARACTER = /[\n\v\f\r\u0085\u2028\u2029]/u
 
 /** The bytes one token stands for, or null for an escape git never writes. */
 const getTokenBytes = (match: RegExpExecArray): Buffer | null => {
@@ -58,15 +59,34 @@ const getTokenBytes = (match: RegExpExecArray): Buffer | null => {
   return Buffer.of(escapeByte)
 }
 
+/**
+ * A rejection naming the path's first line break, or null when it has none.
+ * - The path is PR-author-controlled. It is rendered raw in markdown and in the
+ *   "=== path ===" line annotateDiff writes above each file's hunks. A line
+ *   break would let a filename forge such a line or split a markdown row.
+ * - Other control characters, such as tab, NUL, ESC, and DEL, break no line,
+ *   so they decode. The logger's JSON escapes every C0 character, and DEL
+ *   prints as an invisible byte. Markdown and the prompt keep each one inside
+ *   its line. A workspace read the filesystem refuses falls back to the diff.
+ */
+const getLineBreakRejection = (path: string): QuotedPathDecoding | null => {
+  const lineBreak = LINE_BREAK_CHARACTER.exec(path)?.[0]
+
+  if (!lineBreak) return null
+
+  const codePointHex = lineBreak.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")
+  return { kind: "rejected", reason: `path contains line-break character U+${codePointHex}` }
+}
+
 /** Decodes a path parse-diff returned with git's quotes removed but its
  *  escapes kept. Escaped bytes decode as UTF-8. */
 export const decodeQuotedPath = (path: string): QuotedPathDecoding => {
   // Git quotes any path containing a backslash, whatever core.quotePath says,
   // and every character it quotes becomes an escape that starts with one. So
   // a backslash is present exactly when the path was quoted. GitHub's diff
-  // also quotes every control and non-ASCII character, so an unquoted path
-  // holds none of the characters the check below rejects.
-  if (!path.includes("\\")) return { kind: "unquoted" }
+  // quotes every line break too, but the check still runs on an unquoted path
+  // so the guard does not depend on that quoting.
+  if (!path.includes("\\")) return getLineBreakRejection(path) ?? { kind: "unquoted" }
 
   const byteChunks = Array.from(path.matchAll(QUOTED_PATH_TOKEN), getTokenBytes)
 
@@ -79,27 +99,17 @@ export const decodeQuotedPath = (path: string): QuotedPathDecoding => {
   if (!isUtf8(bytes)) return { kind: "rejected", reason: "escaped bytes are not valid UTF-8" }
 
   const decodedPath = bytes.toString("utf8")
-  const unsafeCharacter = CONTROL_OR_SEPARATOR_CHARACTER.exec(decodedPath)?.[0]
-
-  // The path is PR-author-controlled and is rendered raw in markdown and in
-  // the "=== path ===" line annotateDiff writes above each file's hunks. A
-  // decoded newline would let a filename forge such a line, while the escaped
-  // form breaks no line.
-  if (unsafeCharacter) {
-    const codePointHex = unsafeCharacter.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")
-    return {
-      kind: "rejected",
-      reason: `decoded path contains control or separator character U+${codePointHex}`,
-    }
-  }
 
-  return { kind: "decoded", path: decodedPath }
+  // The escaped form of a line break breaks no line, so a rejected path stays
+  // escaped
+  return getLineBreakRejection(decodedPath) ?? { kind: "decoded", path: decodedPath }
 }
 
 export type DecodedDiffFiles = {
   files: File[]
-  /** Paths whose decoding was rejected. Each stays in its escaped spelling and
-   *  names no file in the checkout or on GitHub. */
+  /** Paths whose decoding was rejected. Each stays as the diff spelled it. A
+   *  quoted one keeps its escapes and names no file in the checkout or on
+   *  GitHub. */
   rejectedPaths: ReadonlySet<string>
 }
 
@@ -119,9 +129,9 @@ export const decodeQuotedFilePaths = (
 
     // A guessed decoding would name a file that does not exist, and the escaped
     // form breaks no line, so the path stays as GitHub's diff shows it. The
-    // checkout has no file at that path, so the file is reviewed from its diff
-    // alone. GitHub rejects a whole review when one inline comment names that
-    // path, so the caller keeps the file out of inline comments.
+    // checkout has no file at an escaped path, so the file is reviewed from its
+    // diff alone. GitHub rejects a whole review when one inline comment names
+    // such a path, so the caller keeps the file out of inline comments.
     if (decoding.kind === "rejected") {
       logger.warn("quoted diff path rejected — kept as received", {
         path: rawPath,
diff --git a/src/orchestrate.ts b/src/orchestrate.ts
index fdd79f7..62a6da5 100644
--- a/src/orchestrate.ts
+++ b/src/orchestrate.ts
@@ -622,10 +622,10 @@ const runReviewPipeline = async (
     })
   }
 
-  // A rejected path keeps git's escapes, so it names no file GitHub knows.
-  // GitHub fails the whole review when one inline comment names such a path,
-  // so the file gets no commentable lines and its findings post as standalone
-  // comments.
+  // A rejected path stays as the diff spelled it. A quoted one keeps git's
+  // escapes, so it names no file GitHub knows. GitHub fails the whole review
+  // when one inline comment names such a path, so the file gets no
+  // commentable lines and its findings post as standalone comments.
   const diffCommentableByPath = computeCommentableLines(reviewableFiles)
   const commentableByPath = new Map(
     Array.from(diffCommentableByPath).filter(([path]) => !rejectedPaths.has(path)),

From fe00c4da2cb26b0c8eec8c6300dd9b6eec66d6d8 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 19:04:53 -0400
Subject: [PATCH 08/15] fix: label rejected-path findings accurately and warn
 once per path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A finding on a file whose diff path was rejected posted with the
beyond-diff location note, though it sits in a changed file. It now gets
its own note. Each distinct diff path decodes and logs once, so a
modified file with a rejected path warns once, and the warning no longer
says "quoted", since unquoted paths are checked too.

Ship-Check: bug-check · claude-opus-5-5
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/__tests__/orchestrate.test.ts            |  3 ++-
 src/diff/__tests__/quoted-paths.test.ts      |  9 ++------
 src/diff/quoted-paths.ts                     | 10 +++++----
 src/orchestrate.ts                           | 15 +++++++++----
 src/review/__tests__/comment-mapping.test.ts | 23 ++++++++++++++++++++
 src/review/comment-mapping.ts                |  9 ++++++++
 6 files changed, 53 insertions(+), 16 deletions(-)

diff --git a/src/__tests__/orchestrate.test.ts b/src/__tests__/orchestrate.test.ts
index 79435ea..ada2849 100644
--- a/src/__tests__/orchestrate.test.ts
+++ b/src/__tests__/orchestrate.test.ts
@@ -22,6 +22,7 @@ import {
   computeAnchorKey,
   mapFindingsToReview,
   renderBeyondDiffFinding,
+  renderRejectedPathFinding,
   renderReroutedFinding,
   REVIEW_MARKER,
   STATUS_ANCHOR,
@@ -1128,7 +1129,7 @@ index 3333333..4444444 100644
       expect(stubs.postIssueCommentCalls).toEqual([
         {
           prNumber: 7,
-          body: renderBeyondDiffFinding(withRoutedModel(rejectedPathFinding, "test/model")),
+          body: renderRejectedPathFinding(withRoutedModel(rejectedPathFinding, "test/model")),
         },
       ])
       expect(
diff --git a/src/diff/__tests__/quoted-paths.test.ts b/src/diff/__tests__/quoted-paths.test.ts
index 8404b55..b956a1a 100644
--- a/src/diff/__tests__/quoted-paths.test.ts
+++ b/src/diff/__tests__/quoted-paths.test.ts
@@ -262,12 +262,7 @@ rename to "docs/\341\213\265-new.md"`
     expect(logger.messages).toEqual([
       {
         level: "warn",
-        message: "quoted diff path rejected — kept as received",
-        data: { path: String.raw`caf\351.md`, reason: "escaped bytes are not valid UTF-8" },
-      },
-      {
-        level: "warn",
-        message: "quoted diff path rejected — kept as received",
+        message: "diff path rejected — kept as received",
         data: { path: String.raw`caf\351.md`, reason: "escaped bytes are not valid UTF-8" },
       },
     ])
@@ -285,7 +280,7 @@ rename to "docs/\341\213\265-new.md"`
     expect(logger.messages).toEqual([
       {
         level: "warn",
-        message: "quoted diff path rejected — kept as received",
+        message: "diff path rejected — kept as received",
         data: {
           path: escapedPath,
           reason: "path contains line-break character U+000A",
diff --git a/src/diff/quoted-paths.ts b/src/diff/quoted-paths.ts
index d03d43b..8f2ef3d 100644
--- a/src/diff/quoted-paths.ts
+++ b/src/diff/quoted-paths.ts
@@ -133,7 +133,7 @@ export const decodeQuotedFilePaths = (
     // diff alone. GitHub rejects a whole review when one inline comment names
     // such a path, so the caller keeps the file out of inline comments.
     if (decoding.kind === "rejected") {
-      logger.warn("quoted diff path rejected — kept as received", {
+      logger.warn("diff path rejected — kept as received", {
         path: rawPath,
         reason: decoding.reason,
       })
@@ -146,9 +146,11 @@ export const decodeQuotedFilePaths = (
     return decoding
   }
 
-  const rawPaths = files
-    .flatMap((file) => [file.from, file.to])
-    .filter((rawPath) => rawPath !== undefined)
+  // A modified file lists one path as both from and to. Each distinct path
+  // decodes and logs once.
+  const rawPaths = Array.from(new Set(files.flatMap((file) => [file.from, file.to]))).filter(
+    (rawPath) => rawPath !== undefined,
+  )
   const decodingByRawPath = new Map(
     rawPaths.map((rawPath): [string, QuotedPathDecoding] => [rawPath, decodePath(rawPath)]),
   )
diff --git a/src/orchestrate.ts b/src/orchestrate.ts
index 62a6da5..fac5832 100644
--- a/src/orchestrate.ts
+++ b/src/orchestrate.ts
@@ -28,6 +28,7 @@ import {
   classifyDuplicate,
   mapFindingsToReview,
   renderBeyondDiffFinding,
+  renderRejectedPathFinding,
   renderReroutedFinding,
   REVIEW_MARKER,
   STATUS_ANCHOR,
@@ -1101,11 +1102,17 @@ const runReviewPipeline = async (
     logger,
   )
 
-  // Beyond-diff findings, plus every in-diff finding when GitHub rejected the
-  // inline review, since one bad anchor fails the whole review. Each keeps a
-  // location note that matches where it sits.
+  // Beyond-diff findings and findings on a rejected diff path, plus every
+  // in-diff finding when GitHub rejected the inline review, since one bad
+  // anchor fails the whole review. Each keeps a location note that matches
+  // where it sits.
   const issueCommentPosts = [
-    ...unanchoredFindings.map((finding) => ({ finding, body: renderBeyondDiffFinding(finding) })),
+    ...unanchoredFindings.map((finding) => ({
+      finding,
+      body: rejectedPaths.has(finding.file)
+        ? renderRejectedPathFinding(finding)
+        : renderBeyondDiffFinding(finding),
+    })),
     ...inlineOutcome.rerouted.map((finding) => ({ finding, body: renderReroutedFinding(finding) })),
   ]
 
diff --git a/src/review/__tests__/comment-mapping.test.ts b/src/review/__tests__/comment-mapping.test.ts
index ab7786d..993a6aa 100644
--- a/src/review/__tests__/comment-mapping.test.ts
+++ b/src/review/__tests__/comment-mapping.test.ts
@@ -9,6 +9,7 @@ import {
   isDuplicateFinding,
   mapFindingsToReview,
   renderBeyondDiffFinding,
+  renderRejectedPathFinding,
   renderReroutedFinding,
   STATUS_ANCHOR,
   type AnchorSource,
@@ -435,6 +436,28 @@ The guard rejects only the exact empty string.
   })
 })
 
+describe("renderRejectedPathFinding", () => {
+  it("places the finding in a changed file whose path cannot take an inline comment", () => {
+    const finding = makeFinding({ file: "src/rejected.ts", line: 1 })
+
+    const body = renderRejectedPathFinding(finding)
+
+    expect(body).toBe(`**Whitespace-only keys pass the empty-key guard**
+Medium severity · correctness · high confidence
+
+\`src/rejected.ts:1\` — in a changed file whose path cannot take an inline comment.
+
+The guard rejects only the exact empty string.
+
+**Failure scenario:** register(" ", "value") succeeds and the entry is orphaned.
+
+---
+*umm-actually · test/model*
+
+<!-- umm-actually:src/rejected.ts:correctness:1 -->`)
+  })
+})
+
 describe("renderReroutedFinding", () => {
   it("places the finding at or near a changed line and says why it posted as its own comment", () => {
     const finding = makeFinding({ file: "src/greeter.ts", line: 145 })
diff --git a/src/review/comment-mapping.ts b/src/review/comment-mapping.ts
index 3af9c53..be0b55a 100644
--- a/src/review/comment-mapping.ts
+++ b/src/review/comment-mapping.ts
@@ -413,6 +413,15 @@ export const renderBeyondDiffFinding = (finding: AttributedFinding): string => {
   })
 }
 
+/** Renders a finding in a changed file whose diff path was rejected. That path
+ *  names no file GitHub knows, so the finding cannot post inline. */
+export const renderRejectedPathFinding = (finding: AttributedFinding): string => {
+  return renderIssueCommentFinding({
+    finding,
+    locationNote: "in a changed file whose path cannot take an inline comment.",
+  })
+}
+
 /** Renders an in-diff finding posted after GitHub rejected the inline review.
  *  Its line is at or near a changed line, not beyond the diff. */
 export const renderReroutedFinding = (finding: AttributedFinding): string => {

From 76b35685ab4734621f3e9b971b6cf00d49adb183 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 20:06:15 -0400
Subject: [PATCH 09/15] fix: escape raw line breaks in rejected diff paths;
 expect the conventions exclusion

A rejected path was kept exactly as received, so an unquoted path with a raw
line separator still reached the annotated-diff header and the job summary.
Each raw line break in a kept rejected path now becomes git's octal escape of
its UTF-8 bytes, and rejectedPaths carries the same spelling.

The doubled-slash exclusion test now expects the conventions file in the
scan exclusions, which main started adding.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/__tests__/orchestrate.test.ts       | 33 +++++++++++++++++++-
 src/diff/__tests__/quoted-paths.test.ts | 19 ++++++++++++
 src/diff/quoted-paths.ts                | 40 +++++++++++++++++--------
 src/orchestrate.ts                      |  6 ++--
 4 files changed, 81 insertions(+), 17 deletions(-)

diff --git a/src/__tests__/orchestrate.test.ts b/src/__tests__/orchestrate.test.ts
index f23e449..0b16df9 100644
--- a/src/__tests__/orchestrate.test.ts
+++ b/src/__tests__/orchestrate.test.ts
@@ -816,7 +816,10 @@ index 3333333..4444444 100644
       await orchestrate(stubs.deps, createTestLogger())
 
       expect(first(stubs.readPriorityDocsCalls).priorityDocs).toEqual(["docs/guide.md"])
-      expect(first(stubs.findRelatedFilesCalls).excludePaths).toEqual(["assets/guide.md"])
+      expect(first(stubs.findRelatedFilesCalls).excludePaths).toEqual([
+        "assets/guide.md",
+        "AGENTS.md",
+      ])
     })
 
     it("passes the budget check when the oversized files are all excluded", async () => {
@@ -1079,6 +1082,34 @@ index 1111111..2222222 100644
       expect(headerLines).toEqual([String.raw`=== nl\n=== forged.ts ===.md ===`])
     })
 
+    it("keeps a filename's raw line separator from forging a header line in the annotated diff", async () => {
+      // GitHub's diff quotes every line break, so this unquoted U+2028 checks
+      // the guard without relying on that quoting
+      const forgingPathDiff = `diff --git a/ls\u2028=== forged.ts ===.md b/ls\u2028=== forged.ts ===.md
+index 1111111..2222222 100644
+--- a/ls\u2028=== forged.ts ===.md
++++ b/ls\u2028=== forged.ts ===.md
+@@ -1 +1 @@
+-old line
++new line
+`
+      const stubs = makeOrchestrateDeps({
+        githubClient: {
+          fetchDiff: async () => ({ kind: "ok" as const, diff: forgingPathDiff }),
+        },
+      })
+
+      /** Every character a renderer may treat as the end of a line. */
+      const lineBreak = /[\n\v\f\r\u0085\u2028\u2029]/u
+
+      await orchestrate(stubs.deps, createTestLogger())
+
+      const headerLines = first(stubs.generateFindingsCalls)
+        .annotatedDiff.split(lineBreak)
+        .filter((line) => line.startsWith("=== "))
+      expect(headerLines).toEqual([String.raw`=== ls\342\200\250=== forged.ts ===.md ===`])
+    })
+
     it("posts a finding on a rejected quoted path as a standalone comment and keeps the rest inline", async () => {
       const escapedPath = String.raw`a\rb.ts`
       const mixedPathDiff = String.raw`diff --git a/src/app.ts b/src/app.ts
diff --git a/src/diff/__tests__/quoted-paths.test.ts b/src/diff/__tests__/quoted-paths.test.ts
index b956a1a..00805b1 100644
--- a/src/diff/__tests__/quoted-paths.test.ts
+++ b/src/diff/__tests__/quoted-paths.test.ts
@@ -289,6 +289,25 @@ rename to "docs/\341\213\265-new.md"`
     ])
   })
 
+  it("escapes the raw line break in a rejected unquoted path and warns with the raw path", () => {
+    const rawPath = "ls\u2028x.md"
+    const escapedPath = String.raw`ls\342\200\250x.md`
+    const file = makeFile({ new: true, from: "/dev/null", to: rawPath })
+    const logger = createTestLogger()
+
+    expect(decodeQuotedFilePaths([file], logger)).toEqual({
+      files: [{ ...file, to: escapedPath }],
+      rejectedPaths: new Set([escapedPath]),
+    })
+    expect(logger.messages).toEqual([
+      {
+        level: "warn",
+        message: "diff path rejected — kept as received",
+        data: { path: rawPath, reason: "path contains line-break character U+2028" },
+      },
+    ])
+  })
+
   it("reports only the rejected path of a rename whose new path decodes", () => {
     const rejectedOldPath = String.raw`old\rname.md`
     const file = makeFile({ from: rejectedOldPath, to: String.raw`\303\245.md` })
diff --git a/src/diff/quoted-paths.ts b/src/diff/quoted-paths.ts
index 8f2ef3d..94cc258 100644
--- a/src/diff/quoted-paths.ts
+++ b/src/diff/quoted-paths.ts
@@ -36,7 +36,7 @@ const CHARACTER_ESCAPE_BYTES = new Map([
 
 /** A character that ends a line: LF, VT, FF, CR, NEL (U+0085), or a Unicode
  *  line or paragraph separator (U+2028, U+2029). */
-const LINE_BREAK_CHARACTER = /[\n\v\f\r\u0085\u2028\u2029]/u
+const LINE_BREAK_CHARACTERS = /[\n\v\f\r\u0085\u2028\u2029]/gu
 
 /** The bytes one token stands for, or null for an escape git never writes. */
 const getTokenBytes = (match: RegExpExecArray): Buffer | null => {
@@ -70,7 +70,7 @@ const getTokenBytes = (match: RegExpExecArray): Buffer | null => {
  *   its line. A workspace read the filesystem refuses falls back to the diff.
  */
 const getLineBreakRejection = (path: string): QuotedPathDecoding | null => {
-  const lineBreak = LINE_BREAK_CHARACTER.exec(path)?.[0]
+  const lineBreak = path.match(LINE_BREAK_CHARACTERS)?.[0]
 
   if (!lineBreak) return null
 
@@ -78,6 +78,17 @@ const getLineBreakRejection = (path: string): QuotedPathDecoding | null => {
   return { kind: "rejected", reason: `path contains line-break character U+${codePointHex}` }
 }
 
+/** The path with each line break written as git's octal escapes of its UTF-8
+ *  bytes, so the path breaks no line. */
+const escapeLineBreaks = (path: string): string => {
+  return path.replaceAll(LINE_BREAK_CHARACTERS, (lineBreak) => {
+    const octalEscapes = Array.from(Buffer.from(lineBreak, "utf8"), (byte) => {
+      return `\\${byte.toString(8).padStart(3, "0")}`
+    })
+    return octalEscapes.join("")
+  })
+}
+
 /** Decodes a path parse-diff returned with git's quotes removed but its
  *  escapes kept. Escaped bytes decode as UTF-8. */
 export const decodeQuotedPath = (path: string): QuotedPathDecoding => {
@@ -107,9 +118,9 @@ export const decodeQuotedPath = (path: string): QuotedPathDecoding => {
 
 export type DecodedDiffFiles = {
   files: File[]
-  /** Paths whose decoding was rejected. Each stays as the diff spelled it. A
-   *  quoted one keeps its escapes and names no file in the checkout or on
-   *  GitHub. */
+  /** Paths whose decoding was rejected. Each stays as the diff spelled it,
+   *  except that a raw line break becomes an octal escape. A quoted one keeps
+   *  its escapes and names no file in the checkout or on GitHub. */
   rejectedPaths: ReadonlySet<string>
 }
 
@@ -127,11 +138,12 @@ export const decodeQuotedFilePaths = (
   const decodePath = (rawPath: string): QuotedPathDecoding => {
     const decoding = decodeQuotedPath(rawPath)
 
-    // A guessed decoding would name a file that does not exist, and the escaped
-    // form breaks no line, so the path stays as GitHub's diff shows it. The
-    // checkout has no file at an escaped path, so the file is reviewed from its
-    // diff alone. GitHub rejects a whole review when one inline comment names
-    // such a path, so the caller keeps the file out of inline comments.
+    // A rejected path stays as GitHub's diff shows it, with any raw line break
+    // escaped, because a guessed decoding would name a file that does not exist.
+    // - The checkout has no file at that path, so the file is reviewed from its
+    //   diff alone.
+    // - GitHub rejects a whole review when one inline comment names such a
+    //   path, so the caller keeps the file out of inline comments.
     if (decoding.kind === "rejected") {
       logger.warn("diff path rejected — kept as received", {
         path: rawPath,
@@ -155,10 +167,12 @@ export const decodeQuotedFilePaths = (
     rawPaths.map((rawPath): [string, QuotedPathDecoding] => [rawPath, decodePath(rawPath)]),
   )
 
-  /** The decoded path, or the path as received when it was unquoted or rejected. */
   const getResolvedPath = (rawPath: string): string => {
     const decoding = decodingByRawPath.get(rawPath)
-    return decoding?.kind === "decoded" ? decoding.path : rawPath
+
+    if (decoding?.kind === "decoded") return decoding.path
+    if (decoding?.kind === "rejected") return escapeLineBreaks(rawPath)
+    return rawPath
   }
 
   const isRejectedPath = (rawPath: string): boolean => {
@@ -171,6 +185,6 @@ export const decodeQuotedFilePaths = (
       ...(file.from && { from: getResolvedPath(file.from) }),
       ...(file.to && { to: getResolvedPath(file.to) }),
     })),
-    rejectedPaths: new Set(rawPaths.filter(isRejectedPath)),
+    rejectedPaths: new Set(rawPaths.filter(isRejectedPath).map(getResolvedPath)),
   }
 }
diff --git a/src/orchestrate.ts b/src/orchestrate.ts
index 676e41f..9a5e894 100644
--- a/src/orchestrate.ts
+++ b/src/orchestrate.ts
@@ -623,9 +623,9 @@ const runReviewPipeline = async (
     })
   }
 
-  // A rejected path stays as the diff spelled it. A quoted one keeps git's
-  // escapes, so it names no file GitHub knows. GitHub fails the whole review
-  // when one inline comment names such a path, so the file gets no
+  // A rejected path keeps git's escapes, and any raw line break in it is
+  // escaped too, so it names no file GitHub knows. GitHub fails the whole
+  // review when one inline comment names such a path, so the file gets no
   // commentable lines and its findings post as standalone comments.
   const diffCommentableByPath = computeCommentableLines(reviewableFiles)
   const commentableByPath = new Map(

From 44f6ab57c2165f3dc7fb7f4d160baed98b7358db Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 20:18:32 -0400
Subject: [PATCH 10/15] fix: match a rejected-path finding on the normalized
 path

The unknown-file filter keeps a finding whose path matches a changed file after normalization, such as ./a\rb.ts, but the rejected-path note was chosen by a raw compare. That finding fell through to the beyond-diff note. The check now compares normalized paths on both sides.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/__tests__/orchestrate.test.ts | 31 +++++++++++++++++++++++++++++++
 src/orchestrate.ts                |  8 +++++++-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/src/__tests__/orchestrate.test.ts b/src/__tests__/orchestrate.test.ts
index 0b16df9..6062330 100644
--- a/src/__tests__/orchestrate.test.ts
+++ b/src/__tests__/orchestrate.test.ts
@@ -1180,6 +1180,37 @@ index 3333333..4444444 100644
       ])
     })
 
+    it("gives the rejected-path note to a finding that spells the rejected path with a leading ./", async () => {
+      const rejectedPathDiff = String.raw`diff --git "a/a\rb.ts" "b/a\rb.ts"
+index 3333333..4444444 100644
+--- "a/a\rb.ts"
++++ "b/a\rb.ts"
+@@ -1 +1 @@
+-old carriage-return line
++new carriage-return line
+`
+      const dotPrefixedFinding = makeFinding({
+        file: String.raw`./a\rb.ts`,
+        line: 1,
+        title: "Carriage-return bug",
+      })
+      const stubs = makeOrchestrateDeps({
+        githubClient: {
+          fetchDiff: async () => ({ kind: "ok" as const, diff: rejectedPathDiff }),
+        },
+        fixtureResult: { review: { analysis: "checked", findings: [dotPrefixedFinding] } },
+      })
+
+      await orchestrate(stubs.deps, createTestLogger())
+
+      expect(stubs.postIssueCommentCalls).toEqual([
+        {
+          prNumber: 7,
+          body: renderRejectedPathFinding(withRoutedModel(dotPrefixedFinding, "test/model")),
+        },
+      ])
+    })
+
     it("keeps a priority doc in the rendered prompt when changed files use the rest of the budget", async () => {
       const priorityDocContent = "# Review reference\nCheck API behavior."
       const priorityDocTokens = estimateTokens(priorityDocContent)
diff --git a/src/orchestrate.ts b/src/orchestrate.ts
index 9a5e894..3e1cfdf 100644
--- a/src/orchestrate.ts
+++ b/src/orchestrate.ts
@@ -68,6 +68,7 @@ import {
   type RunPhase,
 } from "./review/run-stages.js"
 import { selectFindings } from "./review/select-findings.js"
+import { normalizeWorkspacePath } from "./review/workspace-path.js"
 
 /** Priority docs use this share before full changed-file reads. */
 const PRIORITY_DOCS_BUDGET_FLOOR_RATIO = 0.1
@@ -1106,6 +1107,11 @@ const runReviewPipeline = async (
     logger,
   )
 
+  // The unknown-file filter keeps a finding whose path matches a changed file
+  // only after normalizing, such as `./a\rb.ts`. The rejected-path check
+  // compares normalized paths too, so such a finding still gets its note.
+  const normalizedRejectedPaths = new Set(Array.from(rejectedPaths, normalizeWorkspacePath))
+
   // Beyond-diff findings and findings on a rejected diff path, plus every
   // in-diff finding when GitHub rejected the inline review, since one bad
   // anchor fails the whole review. Each keeps a location note that matches
@@ -1113,7 +1119,7 @@ const runReviewPipeline = async (
   const issueCommentPosts = [
     ...unanchoredFindings.map((finding) => ({
       finding,
-      body: rejectedPaths.has(finding.file)
+      body: normalizedRejectedPaths.has(normalizeWorkspacePath(finding.file))
         ? renderRejectedPathFinding(finding)
         : renderBeyondDiffFinding(finding),
     })),

From 25408be24de31abbed429330da7419d9f8e58d04 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 20:26:44 -0400
Subject: [PATCH 11/15] fix: keep path code spans whole when a filename has a
 backtick; document the rejected-path route

Finding locations, the cap note, and the context notes wrapped paths in single backticks, so a filename with a backtick closed the span early. A renderCodeSpan helper now sizes the delimiter past the longest backtick run and pads edge backticks or spaces. The README now names findings on a changed file whose diff path cannot take an inline comment among the standalone comments.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                    |  2 +-
 README.md                                    |  4 ++--
 src/review/__tests__/comment-mapping.test.ts | 20 +++++++++++++++++++
 src/review/__tests__/context-notes.test.ts   | 14 +++++++++++++
 src/review/__tests__/markdown.test.ts        | 20 +++++++++++++++++++
 src/review/comment-mapping.ts                |  5 +++--
 src/review/context-notes.ts                  |  7 ++++---
 src/review/markdown.ts                       | 21 ++++++++++++++++++++
 8 files changed, 85 insertions(+), 8 deletions(-)
 create mode 100644 src/review/__tests__/markdown.test.ts
 create mode 100644 src/review/markdown.ts

diff --git a/AGENTS.md b/AGENTS.md
index 1d75fe0..9cab67b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -29,7 +29,7 @@ src/
   openrouter/              # OpenRouter I/O: @openrouter/sdk wrapper, per-attempt and shared review deadlines, retry and fallback ladder (HTTP errors, timeouts, invalid structured output), cost summary
   diff/                    # pure transforms over parse-diff output: git-quoted path decoding, annotation, commentable lines, diff-level exclusion (patterns, gitattributes linguist rules, wildcard safety cap)
   context/                 # workspace I/O: conventions file, root .gitattributes, changed files, import-trace scan, doc-mention scan, priority docs
-  review/                  # pure review logic: finding schema, phases + stage dispatch, prompt, non-finding filter, unknown-file filter, cross-phase merge, path normalization, selection, comment mapping, title similarity, context notes, summary
+  review/                  # pure review logic: finding schema, phases + stage dispatch, prompt, non-finding filter, unknown-file filter, cross-phase merge, path normalization, selection, comment mapping, markdown code spans, title similarity, context notes, summary
   orchestrate.ts           # pipeline + createPromptedGenerateFindings — fully testable with stub clients
 ```
 
diff --git a/README.md b/README.md
index 7d91856..451a6db 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ LLM-powered pull request review as a GitHub Action. One consolidated review per
 - Structured output end to end: every finding carries a category, severity, confidence, and a concrete failure scenario
 - **Drops non-findings before they post** — findings that conclude "no bug here" (an `N/A — …` title, a "no action needed" suggestion, a "…is correct" title) are filtered deterministically
 - Model-agnostic via OpenRouter — pick your model, see your per-call costs; every finding comment carries an `umm-actually · <model>` byline naming the model that produced that finding
-- Findings that can't be anchored to the diff (e.g. callers outside the changed files) are posted as standalone comments on the PR
+- Findings that can't be anchored to the diff (e.g. callers outside the changed files, or a changed file whose diff path can't take an inline comment) are posted as standalone comments on the PR
 - PRs with oversized diffs are skipped gracefully with a body-only review stating the reason
 - Reports as its **own branded check run** in the PR checks list — the App's avatar, the outcome as the check title (findings count, clean pass, or skip reason), and a details page carrying the summary and per-run cost
 - Surfaces the review context in the workflow job summary — files seen, how much of the conventions file reached the model, which `priority_docs` were included, and the token budget breakdown
@@ -119,7 +119,7 @@ An empty value, such as an unset repo variable, selects the input's default, so
 6. Drops non-findings (see [Non-finding filter](#non-finding-filter)) and findings on files the model was never given (see [Unknown-file filter](#unknown-file-filter)), collapses findings that two phases reported on overlapping lines of the same file, then on re-runs deduplicates against previously posted bot comments (three-tier: positional match by hidden HTML anchor, content match by title similarity within 50 lines in the same file, or title-only match by high title similarity across any file)
 7. Filters remaining findings by severity threshold, deduplicates overlapping findings within the run, and caps if configured
 8. Maps findings to inline PR review comments anchored to diff lines, with a snap-to-nearest-hunk fallback
-9. Posts one review with inline comments (invisible body); beyond-diff findings post as standalone PR comments; every run upserts a status comment with cross-run totals
+9. Posts one review with inline comments (invisible body); beyond-diff findings, and findings in a changed file whose diff path can't take an inline comment, post as standalone PR comments; every run upserts a status comment with cross-run totals
 10. Completes the check run with the outcome — the conclusion grades the run, not the code:
     - `success` for any completed review (with or without findings — the count is in the check title, and a review that lost a phase says so there too)
     - `neutral` for a skip
diff --git a/src/review/__tests__/comment-mapping.test.ts b/src/review/__tests__/comment-mapping.test.ts
index 993a6aa..8a10af8 100644
--- a/src/review/__tests__/comment-mapping.test.ts
+++ b/src/review/__tests__/comment-mapping.test.ts
@@ -456,6 +456,26 @@ The guard rejects only the exact empty string.
 
 <!-- umm-actually:src/rejected.ts:correctness:1 -->`)
   })
+
+  it("keeps the location span whole when the path contains a backtick", () => {
+    const finding = makeFinding({ file: "src/a`b.ts", line: 1 })
+
+    const body = renderRejectedPathFinding(finding)
+
+    expect(body).toBe(`**Whitespace-only keys pass the empty-key guard**
+Medium severity · correctness · high confidence
+
+\`\`src/a\`b.ts:1\`\` — in a changed file whose path cannot take an inline comment.
+
+The guard rejects only the exact empty string.
+
+**Failure scenario:** register(" ", "value") succeeds and the entry is orphaned.
+
+---
+*umm-actually · test/model*
+
+<!-- umm-actually:src/a\`b.ts:correctness:1 -->`)
+  })
 })
 
 describe("renderReroutedFinding", () => {
diff --git a/src/review/__tests__/context-notes.test.ts b/src/review/__tests__/context-notes.test.ts
index 2525678..9d18b68 100644
--- a/src/review/__tests__/context-notes.test.ts
+++ b/src/review/__tests__/context-notes.test.ts
@@ -184,6 +184,20 @@ describe("buildContextNotes", () => {
     ])
   })
 
+  it("keeps a diff-excluded path's code span whole when the path contains a backtick", () => {
+    const notes = buildContextNotes(
+      makeInput({
+        diffExcludedFiles: [
+          { path: "gen/a`b.json", additions: 1, deletions: 0, source: "diff_exclude_paths" },
+        ],
+      }),
+    )
+
+    expect(notes).toEqual([
+      "1 changed file(s) excluded from review: ``gen/a`b.json`` (diff_exclude_paths input)",
+    ])
+  })
+
   it("orders in-context before not-included before related files before related docs before diff exclusions", () => {
     const notes = buildContextNotes(
       makeInput({
diff --git a/src/review/__tests__/markdown.test.ts b/src/review/__tests__/markdown.test.ts
new file mode 100644
index 0000000..bf3a9b4
--- /dev/null
+++ b/src/review/__tests__/markdown.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest"
+import { renderCodeSpan } from "../markdown.js"
+
+describe("renderCodeSpan", () => {
+  it.each([
+    { label: "a plain path", text: "src/app.ts:12", expected: "`src/app.ts:12`" },
+    { label: "a path with one backtick", text: "src/a`b.ts", expected: "``src/a`b.ts``" },
+    {
+      label: "a path whose longest backtick run is two",
+      text: "a`b``c.ts",
+      expected: "```a`b``c.ts```",
+    },
+    { label: "a path that starts with a backtick", text: "`a.ts", expected: "`` `a.ts ``" },
+    { label: "a path that ends with a backtick", text: "a.ts`", expected: "`` a.ts` ``" },
+    { label: "a path that starts with a space", text: " a.ts", expected: "`  a.ts `" },
+    { label: "a path that ends with a space", text: "a.ts ", expected: "` a.ts  `" },
+  ])("wraps $label so no backtick inside closes the span", ({ text, expected }) => {
+    expect(renderCodeSpan(text)).toBe(expected)
+  })
+})
diff --git a/src/review/comment-mapping.ts b/src/review/comment-mapping.ts
index be0b55a..7203b30 100644
--- a/src/review/comment-mapping.ts
+++ b/src/review/comment-mapping.ts
@@ -1,5 +1,6 @@
 import type { CommentableFile } from "../diff/commentable-lines.js"
 import type { AttributedFinding, Finding } from "./finding.js"
+import { renderCodeSpan } from "./markdown.js"
 import { normalizeTitle, titleSimilarity } from "./title-similarity.js"
 
 /** Wire shape for POST /pulls/{n}/reviews comments[] entries. */
@@ -395,7 +396,7 @@ const renderIssueCommentFinding = ({
 }): string => {
   return `${findingHeader(finding)}
 
-\`${finding.file}:${finding.line}\` — ${locationNote}
+${renderCodeSpan(`${finding.file}:${finding.line}`)} — ${locationNote}
 
 ${finding.description}
 
@@ -513,7 +514,7 @@ export const buildStatusComment = ({
   const capNote =
     droppedByCap.length === 0
       ? ""
-      : `_${droppedByCap.length} lower-severity finding(s) omitted by the max_findings cap: ${droppedByCap.map((finding) => `\`${finding.file}:${finding.line}\``).join(", ")}_`
+      : `_${droppedByCap.length} lower-severity finding(s) omitted by the max_findings cap: ${droppedByCap.map((finding) => renderCodeSpan(`${finding.file}:${finding.line}`)).join(", ")}_`
   const incompleteNote = [
     buildIncompleteNote(incompletePhases),
     ...(reviewDeadlineExceeded
diff --git a/src/review/context-notes.ts b/src/review/context-notes.ts
index f7c426e..d3aff74 100644
--- a/src/review/context-notes.ts
+++ b/src/review/context-notes.ts
@@ -1,5 +1,6 @@
 import { posix } from "node:path"
 import { describeExclusionSource, type ExcludedDiffFile } from "../diff/exclusion.js"
+import { renderCodeSpan } from "./markdown.js"
 import { conventionsCharacterCap, conventionsRenderInFull, type PromptFile } from "./prompt.js"
 
 export type ContextNotesInput = {
@@ -22,11 +23,11 @@ export type ContextNotesInput = {
 const normalizePath = (filePath: string): string => posix.normalize(filePath)
 
 const renderCodePaths = (paths: string[]): string => {
-  return paths.map((filePath) => `\`${filePath}\``).join(", ")
+  return paths.map(renderCodeSpan).join(", ")
 }
 
 const renderExcludedFile = (file: ExcludedDiffFile): string => {
-  return `\`${file.path}\` (${describeExclusionSource(file.source)})`
+  return `${renderCodeSpan(file.path)} (${describeExclusionSource(file.source)})`
 }
 
 /** Priority docs satisfied by a higher-priority channel (changed files,
@@ -181,7 +182,7 @@ export const buildConventionsNote = ({
   if (conventionsCoverage.status !== "truncated") return null
 
   const { fullCopyChannel, characterCap, totalCharacters } = conventionsCoverage
-  const fileLabel = `\`${conventionsFile}\``
+  const fileLabel = renderCodeSpan(conventionsFile)
 
   // priority_docs retries a listed file on every PR, and a later PR that cannot
   // fit it gets its own no-copy note, so a listed file needs no warn-ahead
diff --git a/src/review/markdown.ts b/src/review/markdown.ts
new file mode 100644
index 0000000..e1aaa59
--- /dev/null
+++ b/src/review/markdown.ts
@@ -0,0 +1,21 @@
+/** Each run of consecutive backticks. */
+const BACKTICK_RUN = /`+/g
+
+/** A backtick or a space at the start or the end of the text. */
+const EDGE_BACKTICK_OR_SPACE = /^[` ]|[` ]$/
+
+/**
+ * Wraps text in an inline code span that a backtick inside the text cannot
+ * close. File paths reach comments as written, and git never quotes a
+ * backtick, so a single-backtick span would end early.
+ * - The delimiter is one backtick longer than the longest backtick run in the
+ *   text.
+ * - Text that starts or ends with a backtick or a space gets one space on each
+ *   side. CommonMark strips that pair, so the rendered text is unchanged.
+ */
+export const renderCodeSpan = (text: string): string => {
+  const backtickRunLengths = (text.match(BACKTICK_RUN) ?? []).map((run) => run.length)
+  const delimiter = "`".repeat(Math.max(0, ...backtickRunLengths) + 1)
+  const padding = EDGE_BACKTICK_OR_SPACE.test(text) ? " " : ""
+  return `${delimiter}${padding}${text}${padding}${delimiter}`
+}

From 7a1be0eb422f7b1d681295b26ed33a5bb84f1896 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 20:33:39 -0400
Subject: [PATCH 12/15] fix: escape line breaks in workspace paths rendered in
 the job summary and code spans

Workspace-scan paths (related files, mention-matched docs, cap-excluded paths) never pass the diff decoder's line-break check, so a raw newline split the job-summary table row or ended a code span in the context notes. The job-summary list and renderCodeSpan now write each line break as its octal escape first, reusing the decoder's escapeLineBreaks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/diff/quoted-paths.ts                    |  2 +-
 src/review/__tests__/markdown.test.ts       |  4 ++++
 src/review/__tests__/review-summary.test.ts | 11 +++++++++++
 src/review/markdown.ts                      | 16 ++++++++++------
 src/review/review-summary.ts                | 19 +++++++++++++------
 5 files changed, 39 insertions(+), 13 deletions(-)

diff --git a/src/diff/quoted-paths.ts b/src/diff/quoted-paths.ts
index 94cc258..485bdc2 100644
--- a/src/diff/quoted-paths.ts
+++ b/src/diff/quoted-paths.ts
@@ -80,7 +80,7 @@ const getLineBreakRejection = (path: string): QuotedPathDecoding | null => {
 
 /** The path with each line break written as git's octal escapes of its UTF-8
  *  bytes, so the path breaks no line. */
-const escapeLineBreaks = (path: string): string => {
+export const escapeLineBreaks = (path: string): string => {
   return path.replaceAll(LINE_BREAK_CHARACTERS, (lineBreak) => {
     const octalEscapes = Array.from(Buffer.from(lineBreak, "utf8"), (byte) => {
       return `\\${byte.toString(8).padStart(3, "0")}`
diff --git a/src/review/__tests__/markdown.test.ts b/src/review/__tests__/markdown.test.ts
index bf3a9b4..adb4095 100644
--- a/src/review/__tests__/markdown.test.ts
+++ b/src/review/__tests__/markdown.test.ts
@@ -17,4 +17,8 @@ describe("renderCodeSpan", () => {
   ])("wraps $label so no backtick inside closes the span", ({ text, expected }) => {
     expect(renderCodeSpan(text)).toBe(expected)
   })
+
+  it("writes a line break as its octal escape so a blank line cannot end the span", () => {
+    expect(renderCodeSpan("docs/a\n\n# forged.md")).toBe("`docs/a\\012\\012# forged.md`")
+  })
 })
diff --git a/src/review/__tests__/review-summary.test.ts b/src/review/__tests__/review-summary.test.ts
index a710c2e..7b20001 100644
--- a/src/review/__tests__/review-summary.test.ts
+++ b/src/review/__tests__/review-summary.test.ts
@@ -346,4 +346,15 @@ describe("renderReviewSummary", () => {
 
     expect(summary.split("\n")[12]).toBe(String.raw`| Changed files | 1 | src/a\\\|b.ts |`)
   })
+
+  it("escapes a line break in a path so it cannot split the table row", () => {
+    const summary = renderReviewSummary({
+      ...baseStats,
+      changedFilePaths: ["src/x\n| injected |.ts"],
+    })
+
+    expect(summary.split("\n")[12]).toBe(
+      String.raw`| Changed files | 1 | src/x\\012\| injected \|.ts |`,
+    )
+  })
 })
diff --git a/src/review/markdown.ts b/src/review/markdown.ts
index e1aaa59..e72c3cd 100644
--- a/src/review/markdown.ts
+++ b/src/review/markdown.ts
@@ -1,3 +1,5 @@
+import { escapeLineBreaks } from "../diff/quoted-paths.js"
+
 /** Each run of consecutive backticks. */
 const BACKTICK_RUN = /`+/g
 
@@ -5,17 +7,19 @@ const BACKTICK_RUN = /`+/g
 const EDGE_BACKTICK_OR_SPACE = /^[` ]|[` ]$/
 
 /**
- * Wraps text in an inline code span that a backtick inside the text cannot
- * close. File paths reach comments as written, and git never quotes a
- * backtick, so a single-backtick span would end early.
+ * Wraps text in an inline code span that nothing inside the text can close.
+ * File paths reach comments as written. Git never quotes a backtick, and a
+ * workspace-scan path never passes the diff decoder's line-break check.
+ * - Line breaks become octal escapes, since a blank line ends the span.
  * - The delimiter is one backtick longer than the longest backtick run in the
  *   text.
  * - Text that starts or ends with a backtick or a space gets one space on each
  *   side. CommonMark strips that pair, so the rendered text is unchanged.
  */
 export const renderCodeSpan = (text: string): string => {
-  const backtickRunLengths = (text.match(BACKTICK_RUN) ?? []).map((run) => run.length)
+  const singleLineText = escapeLineBreaks(text)
+  const backtickRunLengths = (singleLineText.match(BACKTICK_RUN) ?? []).map((run) => run.length)
   const delimiter = "`".repeat(Math.max(0, ...backtickRunLengths) + 1)
-  const padding = EDGE_BACKTICK_OR_SPACE.test(text) ? " " : ""
-  return `${delimiter}${padding}${text}${padding}${delimiter}`
+  const padding = EDGE_BACKTICK_OR_SPACE.test(singleLineText) ? " " : ""
+  return `${delimiter}${padding}${singleLineText}${padding}${delimiter}`
 }
diff --git a/src/review/review-summary.ts b/src/review/review-summary.ts
index 78b2e9b..4653433 100644
--- a/src/review/review-summary.ts
+++ b/src/review/review-summary.ts
@@ -1,3 +1,4 @@
+import { escapeLineBreaks } from "../diff/quoted-paths.js"
 import type { PrContext } from "../github/event.js"
 import type { ConventionsCoverage, ConventionsFullCopyChannel } from "./context-notes.js"
 
@@ -42,15 +43,21 @@ export type ReviewSummaryStats = {
 }
 
 /** Comma-joined items for one markdown line or table cell — em-dash when
- *  empty so cells are never blank. Backslashes and pipes are escaped, so an
- *  item's own backslash can't cancel a pipe's escape and break the row. */
+ *  empty so cells are never blank. Line breaks, backslashes, and pipes are
+ *  escaped, so no item can split or break the row. */
 const renderCommaList = (items: string[]): string => {
   if (items.length === 0) return "—"
 
-  // Backslashes are escaped first. Escaping pipes first would double each
-  // pipe escape's own backslash and leave the pipe bare. For example, `a\|b`
-  // renders as `a\\\|b`.
-  return items.map((item) => item.replaceAll("\\", "\\\\").replaceAll("|", "\\|")).join(", ")
+  // 1. Line breaks become octal escapes first. Workspace-scan paths never pass
+  //    the diff decoder's line-break check, so a raw one would split the row.
+  // 2. Backslashes are escaped next, including the ones step 1 wrote, so each
+  //    renders as written.
+  // 3. Pipes are escaped last. Escaping them before backslashes would double
+  //    each pipe escape's own backslash and leave the pipe bare. For example,
+  //    `a\|b` renders as `a\\\|b`.
+  return items
+    .map((item) => escapeLineBreaks(item).replaceAll("\\", "\\\\").replaceAll("|", "\\|"))
+    .join(", ")
 }
 
 /** The conventions file and how much of it reached the model. */

From b14ba0cd0ce6b8335e21439b080e26b8c90865e4 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 20:41:14 -0400
Subject: [PATCH 13/15] fix: keep branch-name code spans whole in the job
 summary

Git allows a backtick in a branch name, so the PR line's single-backtick spans around the head and base refs could close early. Both refs now go through renderCodeSpan.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/review/__tests__/review-summary.test.ts | 9 +++++++++
 src/review/review-summary.ts                | 3 ++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/review/__tests__/review-summary.test.ts b/src/review/__tests__/review-summary.test.ts
index 68d85b6..e0753e6 100644
--- a/src/review/__tests__/review-summary.test.ts
+++ b/src/review/__tests__/review-summary.test.ts
@@ -362,6 +362,15 @@ describe("renderReviewSummary", () => {
     expect(summary).not.toContain(baseStats.prContext.headSha)
   })
 
+  it("keeps a branch name's code span whole when it contains a backtick", () => {
+    const summary = renderReviewSummary({
+      ...baseStats,
+      prContext: { ...baseStats.prContext, headRef: "chore/fix`doc" },
+    })
+
+    expect(summary.split("\n")[2]).toBe("PR #7 · ``chore/fix`doc`` → `main` · `abc123d`")
+  })
+
   it("escapes pipe characters in paths so they cannot break the markdown table", () => {
     const summary = renderReviewSummary({
       ...baseStats,
diff --git a/src/review/review-summary.ts b/src/review/review-summary.ts
index bb05483..7cd8253 100644
--- a/src/review/review-summary.ts
+++ b/src/review/review-summary.ts
@@ -1,6 +1,7 @@
 import { escapeLineBreaks } from "../diff/quoted-paths.js"
 import type { PrContext } from "../github/event.js"
 import type { ConventionsCoverage, ConventionsFullCopyChannel } from "./context-notes.js"
+import { renderCodeSpan } from "./markdown.js"
 
 export type ReviewSummaryStats = {
   prContext: PrContext
@@ -110,7 +111,7 @@ export const renderReviewSummary = (stats: ReviewSummaryStats): string => {
   return [
     "### umm-actually review summary",
     "",
-    `PR #${stats.prContext.prNumber} · \`${stats.prContext.headRef}\` → \`${stats.prContext.baseRef}\` · \`${sha}\``,
+    `PR #${stats.prContext.prNumber} · ${renderCodeSpan(stats.prContext.headRef)} → ${renderCodeSpan(stats.prContext.baseRef)} · \`${sha}\``,
     "",
     `**Conventions:** ${renderConventionsCoverage(stats)}`,
     "",

From 12006380bf9b0913591a2d3869857313fe97c5d8 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 20:46:37 -0400
Subject: [PATCH 14/15] docs: say the diff header prints the decoded path in
 the unknown-file filter section

Quoted diff paths are now decoded before the annotated diff is built, so the header shows each double quote as written. A path whose decoding was rejected keeps the escaped spelling.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 36996ee..9bf1804 100644
--- a/README.md
+++ b/README.md
@@ -148,7 +148,7 @@ A finding's `file` (the path it is filed on) must name a file the model was give
 Files removed by `diff_exclude_paths` or linguist rules are listed by path at the end of the diff, but their content is withheld, so findings on them are dropped too and reported as excluded-file drops. When the conventions file is excluded, it is still sent as the review's conventions, but findings on it are dropped like those on any other excluded file. The filter compares paths and reports drops as follows:
 
 - Paths are normalized before comparison: surrounding whitespace, `.` segments, `..` segments that stay inside the repository, repeated slashes, and a leading or trailing `/` don't affect the match (`./src/x.ts`, `/src/x.ts`, and `src/x.ts` match). Matching is case-sensitive, and only whole paths match: a bare filename or a directory prefix does not.
-- A path containing `"` reaches the model with each `"` written as `&quot;` in the tags that wrap each file's content and the conventions file. A diff header prints the path as the diff spells it, and the filter matches that spelling as written. A model that copies the path from a tag writes `&quot;` into `file`, so a `file` that matches no given path as written, but matches once each `&quot;` becomes `"`, is kept and posts under that decoded path. Each such rewrite is logged at debug level (`resolved escaped finding file to a prompt path`) with the model's spelling and the decoded path.
+- A path containing `"` reaches the model with each `"` written as `&quot;` in the tags that wrap each file's content and the conventions file. A diff header prints the decoded path, so each `"` appears as written, and the filter matches that spelling as written. A path whose decoding was rejected keeps the diff's escaped spelling in its header. A model that copies the path from a tag writes `&quot;` into `file`, so a `file` that matches no given path as written, but matches once each `&quot;` becomes `"`, is kept and posts under that decoded path. Each such rewrite is logged at debug level (`resolved escaped finding file to a prompt path`) with the model's spelling and the decoded path.
 - Each drop is logged as a warning with the file, line, and category: `dropping finding: file not in prompt context` for a file the model was never given, and `dropping finding: file excluded from the review diff` for an excluded file. The job summary counts each kind per run, in the `Dropped as unknown file` and `Dropped as excluded file` rows.
 
 ## Debug logging

From cec2d4b7e80e66ec353c2cac0371a1186c7350a6 Mon Sep 17 00:00:00 2001
From: Tanisha Aberdeen <32620895+aliasunder@users.noreply.github.com>
Date: Wed, 30 Sep 2026 21:00:05 -0400
Subject: [PATCH 15/15] fix: escape backticks in job-summary path lists;
 document the rerouted standalone route

Git never quotes a backtick, so two paths with one each in a job-summary cell opened a code span. renderCommaList now escapes backticks after backslashes. The README feature list and step 9 now name the in-diff findings that post as standalone comments when GitHub rejects the inline review.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                                   |  4 ++--
 src/review/__tests__/review-summary.test.ts | 11 +++++++++++
 src/review/review-summary.ts                | 18 ++++++++++++------
 3 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 9bf1804..9d3e920 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ LLM-powered pull request review as a GitHub Action. One consolidated review per
 - Structured output end to end: every finding carries a category, severity, confidence, and a concrete failure scenario
 - **Drops non-findings before they post** — findings that conclude "no bug here" (an `N/A — …` title, a "no action needed" suggestion, a "…is correct" title) are filtered deterministically
 - Model-agnostic via OpenRouter — pick your model, see your per-call costs; every finding comment carries an `umm-actually · <model>` byline naming the model that produced that finding
-- Findings outside the diff on files the model was given (e.g. callers of changed code), and findings in a changed file whose diff path can't take an inline comment, are posted as standalone comments on the PR
+- Findings outside the diff on files the model was given (e.g. callers of changed code), findings in a changed file whose diff path can't take an inline comment, and every in-diff finding when GitHub rejects the inline review are posted as standalone comments on the PR
 - PRs with oversized diffs are skipped gracefully with a body-only review stating the reason
 - Reports as its **own branded check run** in the PR checks list — the App's avatar, the outcome as the check title (findings count, clean pass, or skip reason), and a details page carrying the summary and per-run cost
 - Surfaces the review context in the workflow job summary — files seen, how much of the conventions file reached the model, which `priority_docs` were included, the token budget breakdown, and how many findings each filter step dropped
@@ -119,7 +119,7 @@ An empty value, such as an unset repo variable, selects the input's default, so
 6. Drops non-findings (see [Non-finding filter](#non-finding-filter)) and findings on files the model was never given or that diff exclusion removed (see [Unknown-file filter](#unknown-file-filter)), collapses findings that two phases reported on overlapping lines of the same file, then on re-runs deduplicates against previously posted bot comments (three-tier: positional match by hidden HTML anchor, content match by title similarity within 50 lines in the same file, or title-only match by high title similarity across any file)
 7. Filters remaining findings by severity threshold, drops the less severe of two same-category findings that overlap in the same file (on a tie, the one on the later line), and caps if configured
 8. Maps findings to inline PR review comments anchored to diff lines, with a snap-to-nearest-hunk fallback
-9. Posts one review with inline comments (its body is only a hidden marker); beyond-diff findings, and findings in a changed file whose diff path can't take an inline comment, post as standalone PR comments; every run upserts a status comment with cross-run totals
+9. Posts one review with inline comments (its body is only a hidden marker); beyond-diff findings, findings in a changed file whose diff path can't take an inline comment, and every in-diff finding when GitHub rejects the inline review post as standalone PR comments; every run upserts a status comment with cross-run totals
 10. Completes the check run with the outcome — the conclusion grades the run, not the code:
     - `success` for any completed review (with or without findings — the count is in the check title, and a review that lost a phase says so there too)
     - `neutral` for a skip
diff --git a/src/review/__tests__/review-summary.test.ts b/src/review/__tests__/review-summary.test.ts
index e0753e6..363e6ae 100644
--- a/src/review/__tests__/review-summary.test.ts
+++ b/src/review/__tests__/review-summary.test.ts
@@ -390,6 +390,17 @@ describe("renderReviewSummary", () => {
     expect(summary.split("\n")[12]).toBe(String.raw`| Changed files | 1 | src/a\\\|b.ts |`)
   })
 
+  it("escapes backticks in paths so two in one cell cannot open a code span", () => {
+    const summary = renderReviewSummary({
+      ...baseStats,
+      changedFilePaths: ["src/a`b.ts", "src/c`d.ts"],
+    })
+
+    expect(summary.split("\n")[12]).toBe(
+      String.raw`| Changed files | 2 | src/a\`b.ts, src/c\`d.ts |`,
+    )
+  })
+
   it("escapes a line break in a path so it cannot split the table row", () => {
     const summary = renderReviewSummary({
       ...baseStats,
diff --git a/src/review/review-summary.ts b/src/review/review-summary.ts
index 7cd8253..cee8ffa 100644
--- a/src/review/review-summary.ts
+++ b/src/review/review-summary.ts
@@ -46,8 +46,8 @@ export type ReviewSummaryStats = {
 }
 
 /** Comma-joined items for one markdown line or table cell — em-dash when
- *  empty so cells are never blank. Line breaks, backslashes, and pipes are
- *  escaped, so no item can split or break the row. */
+ *  empty so cells are never blank. Line breaks, backslashes, backticks, and
+ *  pipes are escaped, so no item can split the row or format its text. */
 const renderCommaList = (items: string[]): string => {
   if (items.length === 0) return "—"
 
@@ -55,11 +55,17 @@ const renderCommaList = (items: string[]): string => {
   //    the diff decoder's line-break check, so a raw one would split the row.
   // 2. Backslashes are escaped next, including the ones step 1 wrote, so each
   //    renders as written.
-  // 3. Pipes are escaped last. Escaping them before backslashes would double
-  //    each pipe escape's own backslash and leave the pipe bare. For example,
-  //    `a\|b` renders as `a\\\|b`.
+  // 3. Backticks and pipes are escaped last. Git never quotes a backtick, and
+  //    two in one cell would open a code span. Escaping either before
+  //    backslashes would double its escape's own backslash and leave it bare.
+  //    For example, `a\|b` renders as `a\\\|b`.
   return items
-    .map((item) => escapeLineBreaks(item).replaceAll("\\", "\\\\").replaceAll("|", "\\|"))
+    .map((item) => {
+      return escapeLineBreaks(item)
+        .replaceAll("\\", "\\\\")
+        .replaceAll("`", "\\`")
+        .replaceAll("|", "\\|")
+    })
     .join(", ")
 }