@d3lm/lint-preset 1.5.6 → 1.6.1

package/dist/bin/comments.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/comments/cli.ts
-import { existsSync as existsSync4, realpathSync, statSync as statSync3 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync5, realpathSync, statSync as statSync3 } from "fs";
+import path6 from "path";
 import { parseArgs } from "util";
 
 // src/comments/agent.ts
@@ -17,7 +17,7 @@ var DEFAULT_RULES = `
 
 When rules pull in different directions, the earlier one wins.
 
-1. Keep code and exact text byte for byte, including every punctuation character in it. That covers code blocks, \`@example\`, code spans, identifiers, string literals like error messages, regexes, globs and other patterns like \`*test*\`, URLs, quoted text, titles, and notation like \`host:port\`.
+1. Keep code and exact text byte for byte, including every punctuation character in it. That covers code blocks, \`@example\`, code spans, identifiers, string literals like error messages, regexes, globs and other patterns like \`*test*\`, URLs, quoted text, titles, notation like \`host:port\`, and Rust intra-doc links (see below).
 2. Keep the meaning. An edit may make a comment clearer, never different.
 3. Follow the style preferences below.
 4. Change as little as possible. Wording that already reads clearly stays, even when a note points at it.
@@ -30,10 +30,12 @@ When rules pull in different directions, the earlier one wins.
 - A comment whose whole text is one paragraph stays on a single line when that line fits a separate, larger single-line width, even past the width. Only a longer comment wraps to the width.
 - Separate paragraphs with an empty comment line.
 - Never split a backtick code span across lines.
+- Never split a Markdown link across lines. A link is the text in brackets and the target right after it, like \`[the docs](https://example.com)\`, \`[the docs][label]\`, or \`[the docs]\`, and all of it stays on one line, from its first bracket to its last bracket or parenthesis. An editor can't follow a link that continues on the next line. When a line is too long, break it before or after the link.
 - Keep code blocks, \`@example\`, lists, tables, box drawings, aligned columns, and Markdown hard line breaks (a line that ends with two spaces or a backslash) laid out as they are. List items wrap with their continuation lines indented to the item text, and a JSDoc tag description that doesn't fit continues on the next line without indentation.
 - The tool measures every line, taking the tolerance and the parts it keeps as written into account, and the notes on each comment list what is still wrong. Act on those notes. Don't count columns, and don't apply a stricter limit than the notes show.
 - The maximum is a hard limit for measured prose, including long tokens. If a URL, code span, or other exact text exceeds it, preserve that text and explain the unresolved overflow instead of changing its contents.
 - The tool never rewraps the parts it keeps as written, like a single-line block comment, a paragraph with hard line breaks, or lines that may be laid out by hand. When a note says one of their prose lines is too long, break or shorten it yourself. Exact text and intentional layout win over the width, so keep code, code spans, and the layout in them intact, and if a note can only be fixed by changing them, leave it and say why in your reply.
+- The tool never rewraps a line comment (\`//\`) either. When a note says one of its lines is too long, shorten the wording so the comment fits on its line and still says the same thing. When it can't be shortened without losing meaning, turn it into a multi-line block comment instead: \`/**\` in JavaScript and TypeScript, or \`/*\` in Rust, on its own line, then the text on lines that start with \` * \`, then \` */\` on its own line, all at the indentation of the line comment. Like other block comments, it starts with a capital letter and ends with punctuation. Leave its line breaks to the tool, which rewraps it like any other block comment. Never split a line comment into more \`//\` lines.
 
 ## Style
 
@@ -44,8 +46,16 @@ These are preferences for comment prose. They never apply to code or exact text
 - Prefer a sentence over a "Label: explanation" fragment, like \`...the socket. Optional: without it...\` or \`Default: refuse\` in the middle of prose. A colon is fine where it introduces a list, code block, or example, in a term's definition, in notation, in a quotation, and in a \`Note:\` or \`Optional:\` that starts a comment. A JSDoc tag like \`@note\` or \`@todo\` can replace a label, and \`@default\` fits a default value, not a description.
 - Avoid asterisk emphasis like \`*this*\`, and use plain wording instead. A name or pattern in asterisks, like \`*test*\` or \`*.spec.ts\`, is a pattern, so keep its asterisks and wrap it in a code span, like \`\` \`*test*\` \`\`.
 - Avoid section banner comments, i.e. dividers or headings made of dashes, equals signs, asterisks, or other repeated characters that split a file into visual sections. Let the code structure carry the grouping, or write one short, plain sentence comment (e.g. \`// handlers for control mode\`). Rules that belong to a diagram, a table, a box drawing, a Markdown document, an example, or a legal header aren't banners.
-- Block and JSDoc comments are capitalized and end with punctuation.
-- Never turn a block or JSDoc comment into \`//\` line comments, and never write a run of consecutive \`//\` lines.
+- Block, JSDoc, and Rust doc comments are capitalized and end with punctuation.
+- Never change the kind of a comment, except to turn a line comment that is too long into a block comment (see Layout). Don't turn a block or JSDoc comment into \`//\` line comments, and never write a run of consecutive \`//\` lines. In Rust, a run of \`///\` or \`//!\` lines is one doc comment, so keep its markers, and never turn a doc comment (\`///\`, \`//!\`, \`/**\`, \`/*!\`) into another kind, since that changes or removes documentation.
+
+## Rust doc comments
+
+Rust doc comments are Markdown that rustdoc renders.
+
+- Intra-doc links are exact text. Keep their brackets, backticks, and targets, like \`\` [\`count_provider_reads\`] \`\`, \`\` [\`permissions\`](crate::permissions) \`\`, \`\` [the parser][\`Parser\`] \`\`, or \`[Vec<T>]\`, since rustdoc resolves the text in brackets, or the target after it, as a path. Each link stays on one line (see Layout), including a link with spaces in its text, like \`[the provider module](crate::provider)\`.
+- A link reference definition, like \`\` [\`Foo\`]: crate::Foo \`\`, stays on its own line as it is. Its colon is syntax, not a label.
+- Headings like \`# Examples\`, \`# Panics\`, \`# Errors\`, and \`# Safety\` are sections that rustdoc and readers look for, so keep them. Code blocks are doctests, so keep their lines, including hidden lines that start with \`#\`, exactly as they are.
 
 ## Editing
 
@@ -64,13 +74,13 @@ var RUNNER_COMMANDS = {
 var ISSUE_DESCRIPTIONS = {
   underfill: "ends early, and words from the next line fit on it",
   widow: "leaves fewer than three words on the last line of its paragraph",
-  unbalanced: "is in a paragraph whose lines are less even than the suggested rewrap",
+  unbalanced: "is in a paragraph whose lines are less even than the suggested rewrap, or that splits a link or code span that the rewrap keeps on one line",
   orphan: "may end with the start of a new sentence, clause, or parenthetical, which belongs on the next line (leave it if the period or comma before it is part of an abbreviation, a name, or notation like `No. 3`, or if it is a long word like an identifier and moving it would leave the line far shorter than the lines around it)",
   "split-parenthetical": "may split a parenthetical that the suggested rewrap keeps on one line, past the width but within the maximum (leave it if the split reads as well, like at a comma inside a list, and the line stays closer to the width)",
   "em-dash": "may use an em-dash to join two thoughts (leave it if it's in a quotation, a title, or a string literal, or reads more clearly than the alternatives)",
   banner: "may be a section banner (leave it if it's part of a diagram, a table, a box, a Markdown rule, a separator in an example, or legal text)",
   semicolon: "may join clauses with a semicolon (leave it if it's code, a literal, not a clause join, or reads more clearly than a period or a joining word)",
-  "label-colon": "may use a colon after a label (leave it if it introduces a list or code, defines a term, is notation like a time or `key: value`, or is a `Note:` or `Optional:` that starts the comment)",
+  "label-colon": "may use a colon after a label (leave it if it introduces a list or code, defines a term or a link like `` [`Foo`]: crate::Foo ``, is notation like a time or `key: value`, or is a `Note:` or `Optional:` that starts the comment)",
   emphasis: "may use asterisk emphasis (leave the asterisks of a name or pattern like `*test*`, which belongs in a code span with its asterisks)",
   dash: "may use a spaced hyphen, en-dash, or double hyphen as an em-dash (leave it if it's a range, a CLI argument, arithmetic, code, a term's definition, or reads more clearly than the alternatives)"
 };
@@ -105,7 +115,7 @@ function describeComment(comment) {
     "",
     ...notes.length > 0 ? notes.map((note2) => `- ${note2}`) : ["- no measured issues; review the wording and flow"],
     "",
-    `${fence}ts`,
+    `${fence}${comment.file.endsWith(".rs") ? "rust" : "ts"}`,
     comment.text,
     fence
   ].join("\n");
@@ -293,6 +303,71 @@ function runAgent(invocation, options) {
 // src/comments/analyze.ts
 import { parseSync } from "oxc-parser";
 
+// src/comments/rust.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import path2 from "path";
+import { fileURLToPath } from "url";
+var BINARY_NAME = "comments";
+function platformSuffixes() {
+  const { platform, arch } = process;
+  switch (platform) {
+    case "darwin": {
+      return [`darwin-${arch}`, "darwin-universal"];
+    }
+    case "linux": {
+      return arch === "arm" ? ["linux-arm-gnueabihf", "linux-arm-musleabihf"] : [`linux-${arch}-gnu`, `linux-${arch}-musl`];
+    }
+    case "win32": {
+      return [`win32-${arch}-msvc`, `win32-${arch}-gnu`];
+    }
+    default: {
+      return [`${platform}-${arch}`];
+    }
+  }
+}
+function findBinaries() {
+  const names = platformSuffixes().map((suffix) => `${BINARY_NAME}.${suffix}.node`);
+  for (let directory = path2.dirname(fileURLToPath(import.meta.url)); ; directory = path2.dirname(directory)) {
+    const found = names.map((name) => path2.join(directory, "native", name)).filter((file) => existsSync(file));
+    if (found.length > 0) {
+      return found;
+    }
+    if (path2.dirname(directory) === directory) {
+      return [];
+    }
+  }
+}
+var binding;
+function loadBinding() {
+  if (binding) {
+    return binding;
+  }
+  const require2 = createRequire(import.meta.url);
+  const errors = [];
+  for (const file of findBinaries()) {
+    try {
+      binding = require2(file);
+      return binding;
+    } catch (error) {
+      errors.push(`${file}: ${error.message}`);
+    }
+  }
+  const reason = errors.length > 0 ? `, and loading it failed (${errors.join("; ")})` : "";
+  throw new Error(
+    `comments: Rust files need the native addon for ${process.platform}-${process.arch}${reason}. Build it with \`pnpm run build:native\`, or leave \`.rs\` out of \`extensions\`.`
+  );
+}
+function scanRust(source) {
+  return loadBinding().scanRust(source);
+}
+function rustFingerprint(source) {
+  return loadBinding().rustFingerprint(source);
+}
+function isRustCode(text) {
+  return loadBinding().isRustCode(text);
+}
+
 // src/comments/style.ts
 var BANNER = /^(?!#{1,6}\s)([-=*#_~+/\\])\1{3,}|([-=*#_~])\2{3,}\s*$/;
 var COLUMN_RULE = /^([-=_~])\1*(?:\s+\1+)+$/;
@@ -416,12 +491,94 @@ function findCodeSpanEnd(text, start) {
   }
   return -1;
 }
+function isEscaped(text, index) {
+  let backslashes = 0;
+  while (text[index - 1 - backslashes] === "\\") {
+    backslashes += 1;
+  }
+  return backslashes % 2 === 1;
+}
+function findUnescaped(text, char, start) {
+  for (let index = start; index < text.length; index += 1) {
+    if (text[index] === "\\") {
+      index += 1;
+    } else if (text[index] === char) {
+      return index;
+    }
+  }
+  return -1;
+}
+function findClosingBracket(text, start) {
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    switch (text[index]) {
+      case "\\": {
+        index += 1;
+        break;
+      }
+      case "`": {
+        const close = findCodeSpanEnd(text, index);
+        index = close === -1 ? index + backtickRun(text, index) - 1 : close;
+        break;
+      }
+      case "[": {
+        depth += 1;
+        break;
+      }
+      case "]": {
+        depth -= 1;
+        if (depth === 0) {
+          return index;
+        }
+        break;
+      }
+    }
+  }
+  return -1;
+}
+function findDestinationEnd(text, start) {
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    let close = -1;
+    if (char === "\\") {
+      index += 1;
+    } else if (char === "<" && text.slice(start + 1, index).trim() === "") {
+      close = findUnescaped(text, ">", index + 1);
+    } else if ((char === '"' || char === "'") && /\s/.test(text[index - 1])) {
+      close = findUnescaped(text, char, index + 1);
+    } else if (char === "(") {
+      depth += 1;
+    } else if (char === ")" && --depth === 0) {
+      return index;
+    }
+    index = close === -1 ? index : close;
+  }
+  return -1;
+}
+function findLinkEnd(text, start) {
+  const close = findClosingBracket(text, start);
+  if (close === -1 || text[close + 1] !== "(") {
+    return close;
+  }
+  const end = findDestinationEnd(text, close + 1);
+  return end === -1 ? close : end;
+}
 function tokenize(text) {
+  return splitWords(text, true);
+}
+function splitWords(text, keepLinks) {
   const tokens = [];
   let current = "";
   let index = 0;
   while (index < text.length) {
     const char = text[index];
+    const linkEnd = keepLinks && char === "[" && !isEscaped(text, index) ? findLinkEnd(text, index) : -1;
+    if (linkEnd !== -1) {
+      current += splitWords(text.slice(index, linkEnd + 1), false).join(" ");
+      index = linkEnd + 1;
+      continue;
+    }
     const close = char === "`" ? findCodeSpanEnd(text, index) : char === "{" ? findClosingBrace(text, index) : -1;
     if (char === "`" && close === -1) {
       const run = backtickRun(text, index);
@@ -517,7 +674,7 @@ function isOrphan(previous, token) {
   return opensAside(token) || endsClause(previous) && !CLAUSE_END.test(token);
 }
 function startsBlock(token) {
-  return /^(?:[-*+>]|\d+[.)]|#{1,6})$/.test(token) || /^(?:@[A-Za-z]|`{3}|~{3}|\||<\/?[A-Za-z])/.test(token);
+  return /^(?:\+|-+|=+|\*+|_{3,}|\d+[.)]|#{1,6})$/.test(token) || /^(?:>|@[A-Za-z]|`{3}|~{3}|\||<(?:\/?[A-Za-z]|[!?]))/.test(token);
 }
 function bindLineStarts(tokens, startsLine2 = startsBlock) {
   const units = [];
@@ -955,6 +1112,7 @@ var NAMED_TAGS = /* @__PURE__ */ new Set(["arg", "argument", "param", "prop", "p
 var LINE_DIRECTIVE = /^\s*(?:(?:eslint|oxlint|stylelint)-(?:disable(?:-next-line|-line)?|enable)\b|eslint-env\b|@ts-(?:ignore|expect-error|nocheck|check)\b|@jsx\w*\b|@vite-ignore\b|[@#]__[A-Z_]+__|@(?:vitest|jest)-environment\b|(?:istanbul|c8|v8)\s+ignore\b|prettier-ignore\b|biome-ignore\b|deno-(?:lint-ignore|fmt-ignore)(?:-file)?\b|tslint:|(?:c[sS]pell|spell-?checker)\s*:|(?:webpack|turbopack)[A-Z][a-zA-Z]*\s*:|vim?:\s|#(?:region|endregion)\b|<reference\s)/;
 var BLOCK_DIRECTIVE = /^\s*(?:eslint\s|globals?\s|exported\s|jshint\s|jslint\s|type\s*:)/;
 var LEGAL_COMMENT = /^!|@license\b|@preserve\b|\bcopyright\s+(?:\(c\)|©|\d{4})/i;
+var RUST_LEGAL_COMMENT = /@license\b|@preserve\b|\bcopyright\s+(?:\(c\)|©|\d{4})/i;
 var DEFINITION = /^(?:``|[\w$.[\]]+(?:[ -][\w$.[\]]+)?)(?: [-–]|:) \S/;
 var BOX_DRAWING = /[\u2500-\u257F]/;
 var TABLE_DELIMITER = /^\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)+\|?$/;
@@ -1029,12 +1187,35 @@ ${text}
   }
   return properties.length > 1 || text.trimEnd().endsWith(",") || properties.some((property) => property.type === "Property" && CODE_VALUES.has(property.value.type));
 }
-function isCode(texts) {
-  const text = texts.map((line) => line.replace(LIST_MARKER, "")).join("\n");
-  return parsesAsStatements(text) || parsesAsProperties(text);
+function isCode(texts, language) {
+  return language.isCode(texts.map((line) => line.replace(LIST_MARKER, "")).join("\n"));
 }
 function isCodeLine(text) {
-  return text.endsWith("{") || text.endsWith(";") && (/[()[\]{}=<>]/.test(text) || !/\s/.test(text)) || /^[}\])]/.test(text) || /^(?:const|let|var)\s+[\w$]+\s*[:=]/.test(text) || /^(?:import|export)\s.*(?:\sfrom\s|[{}])/.test(text);
+  return text.endsWith("{") || text.endsWith(";") && (/[()[\]{}=<>]/.test(text) || !/\s/.test(text)) || /^[}\])]/.test(text);
+}
+var JAVASCRIPT = {
+  name: "javascript",
+  isCode: (text) => parsesAsStatements(text) || parsesAsProperties(text),
+  isCodeLine: (text) => {
+    return isCodeLine(text) || /^(?:const|let|var)\s+[\w$]+\s*[:=]/.test(text) || /^(?:import|export)\s.*(?:\sfrom\s|[{}])/.test(text);
+  },
+  legal: LEGAL_COMMENT,
+  blockDirective: BLOCK_DIRECTIVE,
+  tags: true,
+  joinsCodeSpans: true
+};
+var RUST = {
+  name: "rust",
+  isCode: (text) => isRustCode(text),
+  isCodeLine: (text) => {
+    return isCodeLine(text) || /^let\s+(?:mut\s+)?\w+\s*[:=]/.test(text) || /^(?:pub(?:\([\w:\s]+\))?\s+)?(?:const|static(?:\s+mut)?)\s+[A-Z_\d]+\s*:/.test(text) || /^(?:pub(?:\([\w:\s]+\))?\s+)?use\s+[\w:]*::/.test(text) || /^#!?\[/.test(text);
+  },
+  legal: RUST_LEGAL_COMMENT,
+  tags: false,
+  joinsCodeSpans: false
+};
+function languageOf(filename) {
+  return filename.endsWith(".rs") ? RUST : JAVASCRIPT;
 }
 function layoutReason(prose, raw) {
   if (prose.startsWith("|") || TABLE_DELIMITER.test(prose)) {
@@ -1048,8 +1229,10 @@ function layoutReason(prose, raw) {
   }
   return void 0;
 }
+var THEMATIC_BREAK = /^(?:(?:\*\s*){3,}|(?:-\s*){3,}|(?:_\s*){3,})$/;
 function isMarkup(prose) {
-  return /^#{1,6}\s/.test(prose) || /^\[[^\]]+\]:/.test(prose) || /^<\/?[a-z]/i.test(prose) || /^>(?:\s|$)/.test(prose);
+  const text = prose.replace(LIST_MARKER, "");
+  return /^#{1,6}(?:\s|$)/.test(text) || /^\[[^\]]+\]:/.test(text) || /^<(?:\/?[a-z]|[!?])/i.test(text) || text.startsWith(">") || /^(?:=+|-+)$/.test(prose) || THEMATIC_BREAK.test(prose);
 }
 function mask(text) {
   return text.replaceAll(/[^\n]/g, "x");
@@ -1076,11 +1259,14 @@ function hasAlignedColumns(lines) {
   }
   return false;
 }
-function structureOf(lines) {
+function structureOf(lines, language) {
   const trimmed = lines.map((line) => line.text.trim()).join("\n");
   const texts = replaceKeepingLines(trimmed, CODE_SPAN, "``").split("\n");
   const proseLines = stripNonProse(trimmed).split("\n");
-  if (isCode(lines.map((line) => line.text.trim()))) {
+  if (isCode(
+    lines.map((line) => line.text.trim()),
+    language
+  )) {
     return { tier: "code", reason: "code" };
   }
   let layout;
@@ -1089,7 +1275,7 @@ function structureOf(lines) {
   for (const [position, line] of texts.entries()) {
     const prose = proseLines[position].trim();
     layout ??= layoutReason(prose, lines[position]?.text ?? "");
-    if (isCodeLine(line.trim())) {
+    if (language.isCodeLine(line.trim())) {
       codeLike = true;
     } else if (isMarkup(prose)) {
       manual ??= "markup";
@@ -1128,7 +1314,7 @@ var FenceTracker = class {
     return true;
   }
 };
-function segment(lines) {
+function segment(lines, language) {
   const paragraphs = [];
   const fence = new FenceTracker();
   let current;
@@ -1165,6 +1351,10 @@ function segment(lines) {
       continue;
     }
     if (line.verbatim) {
+      if (fence.next(text)) {
+        start("code", line, "", "code block");
+        continue;
+      }
       start("code", line, "", "directive");
       flush();
       continue;
@@ -1189,7 +1379,7 @@ function segment(lines) {
       }
       continue;
     }
-    const tag = JSDOC_TAG.exec(text);
+    const tag = language.tags ? JSDOC_TAG.exec(text) : null;
     if (tag) {
       start("tag", line, "", PROSE_TAGS.has(tag[1]) ? void 0 : `@${tag[1]} tag`);
       inCodeTag = CODE_TAGS.has(tag[1]);
@@ -1296,7 +1486,19 @@ function byLine(issues) {
 function sameLayout(a, b) {
   return a.length === b.length && a.every((words, position) => words.join(" ") === b[position].join(" "));
 }
-function analyzeParagraph(paragraph, options) {
+function splitTokenLine(lines, tokens) {
+  let next = 0;
+  return lines.findIndex((words) => {
+    const line = words.join(" ");
+    let text = "";
+    while (text.length < line.length && next < tokens.length) {
+      text += `${text ? " " : ""}${tokens[next]}`;
+      next += 1;
+    }
+    return text !== line;
+  });
+}
+function analyzeParagraph(paragraph, options, language) {
   const first = paragraph.lines[0];
   const last = paragraph.lines.at(-1) ?? first;
   const base = { kind: paragraph.kind, startLine: first.index + 1, endLine: last.index + 1 };
@@ -1323,7 +1525,8 @@ function analyzeParagraph(paragraph, options) {
     const structure2 = structureOf(
       prose.lines.map((line) => {
         return { ...line, text: stripBlockSyntax(line.text) };
-      })
+      }),
+      language
     );
     const issues2 = keptIssues(prose, structure2, options);
     return { ...base, reflowable: false, reason: paragraph.reason, issues: issues2, suggestion: null };
@@ -1332,7 +1535,7 @@ function analyzeParagraph(paragraph, options) {
     const issues2 = keptIssues(paragraph, structure2, options);
     return { ...base, reflowable: false, reason: structure2.reason, issues: issues2, suggestion: null };
   };
-  const structure = structureOf(paragraph.lines);
+  const structure = structureOf(paragraph.lines, language);
   if (structure) {
     return keep(structure);
   }
@@ -1364,10 +1567,14 @@ function analyzeParagraph(paragraph, options) {
   if (!units.every((unit) => staysInLimit(unit))) {
     return keep({ tier: "manual", reason: "unbreakable text across lines" });
   }
+  const text = currentLines.map((words) => words.join(" ")).join("\n");
+  if (!language.joinsCodeSpans && [...text.matchAll(CODE_SPAN)].some((span) => span[0].includes("\n"))) {
+    return keep({ tier: "manual", reason: "code span across lines" });
+  }
   const bodyOf = (lines) => {
     return lines.map((words, position) => {
-      const text = `${position === 0 ? paragraph.marker : hang}${words.join(" ")}`;
-      return { ...first, text, verbatim: false, hardBreak: HARD_BREAK.test(text) };
+      const text2 = `${position === 0 ? paragraph.marker : hang}${words.join(" ")}`;
+      return { ...first, text: text2, verbatim: false, hardBreak: HARD_BREAK.test(text2) };
     });
   };
   const settle = (settings, extra = 0) => {
@@ -1375,11 +1582,11 @@ function analyzeParagraph(paragraph, options) {
     let { even: even2, wrapped: wrapped2 } = layOut(current, settings, extra);
     for (; ; ) {
       const body = bodyOf(wrapped2);
-      const rewrap = structureOf(body);
+      const rewrap = structureOf(body, language);
       if (!rewrap) {
         return { even: even2, wrapped: wrapped2 };
       }
-      const tipping = body.findIndex((_, position) => structureOf(body.slice(0, position + 1)) !== void 0);
+      const tipping = body.findIndex((_, position) => structureOf(body.slice(0, position + 1), language) !== void 0);
       const start = wrapped2.slice(0, Math.max(tipping, 1)).flat().length;
       const pair = `${current[start - 1]} ${current[start]}`;
       if (body.length < 2 || !staysInLimit(pair)) {
@@ -1405,6 +1612,7 @@ function analyzeParagraph(paragraph, options) {
   }
   const { even, wrapped } = layout;
   const matchesLayout = sameLayout(wrapped, currentLines);
+  const isVerdict = (issue) => ISSUE_TIERS[issue.type] === "verdict";
   const lineIssues = [];
   const overflow = options.maxWidth === void 0 ? [] : overflowIssues(paragraph.lines, options);
   if (!matchesLayout) {
@@ -1463,8 +1671,11 @@ function analyzeParagraph(paragraph, options) {
         lineIssues.push({ type: "unbalanced", line });
       }
     }
+    const splitLine = splitTokenLine(currentLines, tokens);
+    if (splitLine !== -1 && overflow.length === 0 && !lineIssues.some((issue) => isVerdict(issue))) {
+      lineIssues.push({ type: "unbalanced", line: splitLine });
+    }
   }
-  const isVerdict = (issue) => ISSUE_TIERS[issue.type] === "verdict";
   const matchesWiderLayout = () => {
     for (let extra = 1; extra <= layoutOptions.tolerance; extra += 1) {
       const wider = layoutAt(extra);
@@ -1474,7 +1685,20 @@ function analyzeParagraph(paragraph, options) {
     }
     return false;
   };
-  const accepted = lineIssues.some((issue) => isVerdict(issue)) && matchesWiderLayout();
+  const staysNearLayout = () => {
+    if (currentLines.length !== wrapped.length || splitTokenLine(currentLines, units) !== -1) {
+      return false;
+    }
+    return currentLines.every((words, position) => {
+      const length = words.join(" ").length;
+      const suggestedLength = wrapped[position].join(" ").length;
+      const limit = (position === 0 ? firstLimit : restLimit) + layoutOptions.tolerance;
+      return Math.abs(length - suggestedLength) <= layoutOptions.tolerance && length <= Math.max(suggestedLength, limit);
+    });
+  };
+  const hasVerdict = lineIssues.some((issue) => isVerdict(issue));
+  const onlyUnbalanced = lineIssues.every((issue) => issue.type === "unbalanced");
+  const accepted = hasVerdict && (matchesWiderLayout() || onlyUnbalanced && staysNearLayout());
   const suggested = accepted ? currentLines : wrapped;
   const suggestion = suggested.map(
     (words, position) => `${prefix}${position === 0 ? paragraph.marker : hang}${words.join(" ")}`
@@ -1483,6 +1707,18 @@ function analyzeParagraph(paragraph, options) {
   const issues = byLine([...overflow, ...wrapIssues, ...styleIssues(paragraph, options)]);
   return { ...base, reflowable: true, issues, suggestion };
 }
+var LINE_COMMENT = "line comment";
+function analyzeLineParagraph(paragraph, options, language) {
+  const first = paragraph.lines[0];
+  const last = paragraph.lines.at(-1) ?? first;
+  const base = { kind: paragraph.kind, startLine: first.index + 1, endLine: last.index + 1 };
+  if (paragraph.kind === "code") {
+    return { ...base, reflowable: false, reason: paragraph.reason, issues: [], suggestion: null };
+  }
+  const tier = structureOf(paragraph.lines, language)?.tier;
+  const issues = tier === "code" || tier === "layout" ? [] : overflowIssues(paragraph.lines, options);
+  return { ...base, reflowable: false, reason: LINE_COMMENT, issues, suggestion: null };
+}
 function computeLineStarts(source) {
   const starts = [0];
   for (let index = 0; index < source.length; index += 1) {
@@ -1508,31 +1744,42 @@ function lineOf(lineStarts, offset) {
 function stripCarriageReturn(line) {
   return line.endsWith("\r") ? line.slice(0, -1) : line;
 }
-function shapeBlock(comment, sourceLines, lineStarts) {
+function blockKind(comment, language) {
+  if (language.name === "rust") {
+    return comment.doc ? `${comment.doc}-block-doc` : "block";
+  }
+  return comment.value.startsWith("*") ? "jsdoc" : "block";
+}
+function wholeComment(shape, lines, paragraphKind, reason) {
+  const otherLines = lines.map((text, offset) => {
+    return { index: shape.startLine + offset, prefix: "", text, verbatim: false, hardBreak: false };
+  });
+  return { ...shape, paragraphs: [{ kind: paragraphKind, marker: "", reason, lines: otherLines }] };
+}
+function isLegal(value, language) {
+  return language.legal.test(replaceKeepingLines(value, CODE_SPAN, "``"));
+}
+function shapeBlock(comment, sourceLines, lineStarts, language) {
   const startLine = lineOf(lineStarts, comment.start);
   const endLine = lineOf(lineStarts, comment.end - 1);
-  const kind = comment.value.startsWith("*") ? "jsdoc" : "block";
+  const shape = { kind: blockKind(comment, language), startLine, endLine };
   const lines = sourceLines.slice(startLine, endLine + 1);
-  const wholeComment = (paragraphKind, reason) => {
-    const otherLines = lines.map((text, offset) => {
-      return { index: startLine + offset, prefix: "", text, verbatim: false, hardBreak: false };
-    });
-    return { kind, startLine, endLine, paragraphs: [{ kind: paragraphKind, marker: "", reason, lines: otherLines }] };
-  };
-  const value = comment.value.replace(/^\*/, "");
-  if (LEGAL_COMMENT.test(replaceKeepingLines(comment.value, CODE_SPAN, "``"))) {
-    return wholeComment("code", "legal comment");
+  const value = comment.doc ? comment.value.slice(1) : comment.value.replace(/^\*/, "");
+  if (isLegal(comment.value, language)) {
+    return wholeComment(shape, lines, "code", "legal comment");
   }
-  if (LINE_DIRECTIVE.test(value) || BLOCK_DIRECTIVE.test(value)) {
-    return wholeComment("code", "directive");
+  if (LINE_DIRECTIVE.test(value) || language.blockDirective?.test(value)) {
+    return wholeComment(shape, lines, "code", "directive");
   }
   const other = () => {
     return wholeComment(
+      shape,
+      lines,
       "other",
       startLine === endLine ? "single-line block comment" : "unsupported block comment layout"
     );
   };
-  if (startLine === endLine || !/^\s*\/\*\*?$/.test(lines[0]) || !/^\s*\*\/$/.test(lines.at(-1) ?? "")) {
+  if (startLine === endLine || !/^\s*\/\*[*!]?$/.test(lines[0]) || !/^\s*\*\/$/.test(lines.at(-1) ?? "")) {
     return other();
   }
   const body = [];
@@ -1551,7 +1798,52 @@ function shapeBlock(comment, sourceLines, lineStarts) {
       hardBreak: HARD_BREAK.test(text)
     });
   }
-  return { kind, startLine, endLine, paragraphs: segment(body) };
+  return { ...shape, paragraphs: segment(body, language) };
+}
+function shapeLineRun(group, sourceLines, lineStarts, language) {
+  const startLine = lineOf(lineStarts, group[0].start);
+  const endLine = startLine + group.length - 1;
+  const kind = group[0].doc === "inner" ? "inner-line-doc" : "outer-line-doc";
+  const shape = { kind, startLine, endLine };
+  const lines = sourceLines.slice(startLine, endLine + 1);
+  const values = group.map((comment) => comment.value.slice(1));
+  if (isLegal(values.join("\n"), language)) {
+    return wholeComment(shape, lines, "code", "legal comment");
+  }
+  if (LINE_DIRECTIVE.test(values[0])) {
+    return wholeComment(shape, lines, "code", "directive");
+  }
+  const body = lines.map((line, offset) => {
+    const [, marker, space, text] = /^(\s*\/\/[/!])( ?)(.*)$/.exec(line) ?? ["", "", "", line];
+    return {
+      index: startLine + offset,
+      prefix: `${marker} `,
+      text: text.trimEnd(),
+      verbatim: !space && text.length > 0 || LINE_DIRECTIVE.test(text),
+      hardBreak: HARD_BREAK.test(text)
+    };
+  });
+  return { ...shape, paragraphs: segment(body, language) };
+}
+function shapeLineComment(group, sourceLines, lineStarts, language) {
+  const startLine = lineOf(lineStarts, group[0].start);
+  const endLine = startLine + group.length - 1;
+  const shape = { kind: "line", startLine, endLine };
+  const lines = sourceLines.slice(startLine, endLine + 1);
+  if (isLegal(group.map((comment) => comment.value).join("\n"), language)) {
+    return wholeComment(shape, lines, "code", "legal comment");
+  }
+  const body = lines.map((line, offset) => {
+    const [, marker, space, text] = /^(\s*\/\/[/!]*)( ?)(.*)$/.exec(line) ?? ["", "", "", line];
+    return {
+      index: startLine + offset,
+      prefix: `${marker}${space}`,
+      text: text.trimEnd(),
+      verbatim: LINE_DIRECTIVE.test(text),
+      hardBreak: HARD_BREAK.test(text)
+    };
+  });
+  return { ...shape, paragraphs: segment(body, { ...language, tags: false }) };
 }
 function ownsLines(comment, source, lineStarts) {
   const startLine = lineOf(lineStarts, comment.start);
@@ -1561,12 +1853,12 @@ function ownsLines(comment, source, lineStarts) {
   const after = source.slice(comment.end, lineEnd);
   return /^[\t ]*$/.test(before) && /^[\t ]*\r?\n?$/.test(after);
 }
-function singleLineLength(paragraph, options) {
+function singleLineLength(paragraph, options, language) {
   const [first] = paragraph.lines;
   if (paragraph.kind === "other" && paragraph.reason === "single-line block comment") {
     return sourceLineLength(first, options.tabWidth);
   }
-  if (paragraph.kind !== "prose" || structureOf(paragraph.lines)) {
+  if (paragraph.kind !== "prose" || structureOf(paragraph.lines, language)) {
     return Infinity;
   }
   const text = tokenize(paragraph.lines.map((line) => line.text).join(" ")).join(" ");
@@ -1581,33 +1873,73 @@ function describeFailure(errors, lineStarts) {
   const offset = first.labels.at(0)?.start;
   return { message: first.message, line: offset === void 0 ? void 0 : lineOf(lineStarts, offset) + 1 };
 }
+function scanJavaScript(filename, text, lineStarts) {
+  const { program, comments, errors } = parseSource(filename, text);
+  if (errors.length > 0 && program.body.length === 0) {
+    return { comments: [], syntaxError: describeFailure(errors, lineStarts) };
+  }
+  return {
+    comments: comments.filter((comment) => !(comment.start === 0 && text.startsWith("#!")))
+  };
+}
+function scanRustSource(text, lineStarts) {
+  const { comments, error } = scanRust(text);
+  if (error) {
+    return { comments: [], syntaxError: { message: error.message, line: lineOf(lineStarts, error.offset) + 1 } };
+  }
+  return {
+    comments: comments.map((comment) => {
+      return {
+        type: comment.block ? "Block" : "Line",
+        value: text.slice(comment.start + 2, comment.block ? comment.end - 2 : comment.end),
+        start: comment.start,
+        end: comment.end,
+        doc: comment.doc
+      };
+    })
+  };
+}
+function groupLineRuns(comments, text, lineStarts, markerOf) {
+  const groups = [];
+  let current;
+  let previousLine = -1;
+  let indent = "";
+  let marker;
+  for (const comment of comments) {
+    const next = comment.type === "Line" ? markerOf(comment) : void 0;
+    if (next === void 0 || !ownsLines(comment, text, lineStarts)) {
+      current = void 0;
+      continue;
+    }
+    const line = lineOf(lineStarts, comment.start);
+    const before = text.slice(lineStarts[line], comment.start);
+    if (current && line === previousLine + 1 && next === marker && before === indent) {
+      current.push(comment);
+    } else {
+      current = [comment];
+      indent = before;
+      marker = next;
+      groups.push(current);
+    }
+    previousLine = line;
+  }
+  return groups;
+}
 function inspectSource(source, filename, options) {
   if (options.maxWidth !== void 0 && (!Number.isInteger(options.maxWidth) || options.maxWidth < options.width)) {
     throw new Error("comments: maxWidth must be an integer at least as large as width");
   }
   const text = source.startsWith(BYTE_ORDER_MARK) ? source.slice(1) : source;
-  const { program, comments, errors } = parseSource(filename, text);
+  const language = languageOf(filename);
   const lineStarts = computeLineStarts(text);
-  if (errors.length > 0 && program.body.length === 0) {
-    return { comments: [], syntaxError: describeFailure(errors, lineStarts) };
+  const scanned = language.name === "rust" ? scanRustSource(text, lineStarts) : scanJavaScript(filename, text, lineStarts);
+  if (scanned.syntaxError) {
+    return { comments: [], syntaxError: scanned.syntaxError };
   }
   const sourceLines = text.split("\n").map((line) => stripCarriageReturn(line));
-  const parsed = comments.filter((comment) => !(comment.start === 0 && text.startsWith("#!")));
   const reports = [];
-  const blocks = parsed.filter((comment) => {
-    return comment.type === "Block" && ownsLines(comment, text, lineStarts) && !comment.value.includes(IGNORE_DIRECTIVE);
-  });
-  for (const block of blocks) {
-    const shape = shapeBlock(block, sourceLines, lineStarts);
-    const singleLineWidth = Math.max(
-      options.width,
-      Math.min(options.singleLineWidth ?? options.width, options.maxWidth ?? Infinity)
-    );
-    const singleLineLimit = Math.min(singleLineWidth + options.tolerance, options.maxWidth ?? Infinity);
-    const singleLine = shape.paragraphs.length === 1 ? singleLineLength(shape.paragraphs[0], options) : Infinity;
-    const paragraphOptions = singleLine <= singleLineLimit ? { ...options, width: Math.max(singleLineWidth, singleLine) } : options;
-    const lines = sourceLines.slice(shape.startLine, shape.endLine + 1);
-    reports.push({
+  const report = (shape, lines, paragraphs) => {
+    return {
       file: filename,
       kind: shape.kind,
       startLine: shape.startLine + 1,
@@ -1617,8 +1949,47 @@ function inspectSource(source, filename, options) {
       maxWidth: options.maxWidth,
       lengths: lines.map((line) => visualLength(line.trimEnd(), options.tabWidth)),
       text: lines.join("\n"),
-      paragraphs: shape.paragraphs.map((paragraph) => analyzeParagraph(paragraph, paragraphOptions))
+      paragraphs
+    };
+  };
+  const blocks = scanned.comments.filter((comment) => {
+    return comment.type === "Block" && ownsLines(comment, text, lineStarts) && !comment.value.includes(IGNORE_DIRECTIVE);
+  });
+  const runs = (markerOf) => {
+    return groupLineRuns(scanned.comments, text, lineStarts, markerOf).filter((group) => {
+      return !group.some((comment) => comment.value.includes(IGNORE_DIRECTIVE));
     });
+  };
+  const shapes = [
+    ...blocks.map((block) => shapeBlock(block, sourceLines, lineStarts, language)),
+    ...runs((comment) => comment.doc).map((group) => shapeLineRun(group, sourceLines, lineStarts, language)),
+    ...runs((comment) => comment.doc ? void 0 : "//").map(
+      (group) => shapeLineComment(group, sourceLines, lineStarts, language)
+    )
+  ].toSorted((a, b) => a.startLine - b.startLine);
+  for (const shape of shapes) {
+    const lines = sourceLines.slice(shape.startLine, shape.endLine + 1);
+    if (shape.kind === "line") {
+      const paragraphs = shape.paragraphs.map((paragraph) => analyzeLineParagraph(paragraph, options, language));
+      if (paragraphs.some((paragraph) => paragraph.issues.length > 0)) {
+        reports.push(report(shape, lines, paragraphs));
+      }
+      continue;
+    }
+    const singleLineWidth = Math.max(
+      options.width,
+      Math.min(options.singleLineWidth ?? options.width, options.maxWidth ?? Infinity)
+    );
+    const singleLineLimit = Math.min(singleLineWidth + options.tolerance, options.maxWidth ?? Infinity);
+    const singleLine = shape.paragraphs.length === 1 ? singleLineLength(shape.paragraphs[0], options, language) : Infinity;
+    const paragraphOptions = singleLine <= singleLineLimit ? { ...options, width: Math.max(singleLineWidth, singleLine) } : options;
+    reports.push(
+      report(
+        shape,
+        lines,
+        shape.paragraphs.map((paragraph) => analyzeParagraph(paragraph, paragraphOptions, language))
+      )
+    );
   }
   return { comments: reports };
 }
@@ -1639,6 +2010,9 @@ function rewrapComment(report) {
 }
 var POSITION_KEYS = /* @__PURE__ */ new Set(["start", "end", "range", "loc"]);
 function codeFingerprint(source, filename) {
+  if (languageOf(filename).name === "rust") {
+    return rustFingerprint(source);
+  }
   const { program, errors } = parseSource(filename, source);
   if (errors.length > 0) {
     return JSON.stringify({ source, errors: errors.map((error) => error.message) });
@@ -1650,11 +2024,11 @@ function codeFingerprint(source, filename) {
 }
 
 // src/comments/config.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { createRequire } from "module";
-import path2 from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import path3 from "path";
 import { pathToFileURL } from "url";
-var DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"]);
+var DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts", ".rs"]);
 var CONFIG_FILES = [
   "comments.config.ts",
   "comments.config.mts",
@@ -1702,10 +2076,12 @@ function validateConfig(raw, filepath) {
   assertType(config.avoidSentenceOrphans, "boolean", "avoidSentenceOrphans", filepath);
   assertType(config.style, "boolean", "style", filepath);
   assertType(config.extensions, "array", "extensions", filepath);
+  assertType(config.include, "array", "include", filepath);
   assertType(config.ignore, "array", "ignore", filepath);
   assertType(config.agent, "object", "agent", filepath);
   assertType(config.hook, "object", "hook", filepath);
   assertStrings(config.extensions, "extensions", filepath);
+  assertStrings(config.include, "include", filepath);
   assertStrings(config.ignore, "ignore", filepath);
   for (const key of ["width", "maxWidth", "singleLineWidth", "tolerance"]) {
     const value = config[key];
@@ -1738,8 +2114,8 @@ function validateConfig(raw, filepath) {
   }
   assertType(agent.rules, "string", "agent.rules", filepath);
   assertType(agent.instructions, "string", "agent.instructions", filepath);
-  if (agent.scope !== void 0 && agent.scope !== "suspicious" && agent.scope !== "all") {
-    throw new Error(`comments: \`agent.scope\` in ${filepath} must be "suspicious" or "all"`);
+  if (agent.scope !== void 0 && !["suspicious", "failing", "all"].includes(agent.scope)) {
+    throw new Error(`comments: \`agent.scope\` in ${filepath} must be one of suspicious, failing, all`);
   }
   const hook = config.hook ?? {};
   if (hook.mode !== void 0 && !["agent", "report", "off"].includes(hook.mode)) {
@@ -1749,25 +2125,25 @@ function validateConfig(raw, filepath) {
 }
 async function loadConfig(cwd, options = {}) {
   if (options.explicitPath) {
-    const filepath = path2.resolve(cwd, options.explicitPath);
+    const filepath = path3.resolve(cwd, options.explicitPath);
     return { config: validateConfig(await readConfigFile(filepath), filepath), filepath };
   }
-  let directory = path2.resolve(cwd);
+  let directory = path3.resolve(cwd);
   for (; ; ) {
     for (const name of CONFIG_FILES) {
-      const filepath = path2.join(directory, name);
-      if (existsSync(filepath)) {
+      const filepath = path3.join(directory, name);
+      if (existsSync2(filepath)) {
         return { config: validateConfig(await readConfigFile(filepath), filepath), filepath };
       }
     }
-    const packageJsonPath = path2.join(directory, "package.json");
-    if (existsSync(packageJsonPath)) {
+    const packageJsonPath = path3.join(directory, "package.json");
+    if (existsSync2(packageJsonPath)) {
       const value = readJson(packageJsonPath)[PACKAGE_JSON_KEY];
       if (value !== void 0) {
         return { config: validateConfig(value, packageJsonPath), filepath: packageJsonPath };
       }
     }
-    const parent = path2.dirname(directory);
+    const parent = path3.dirname(directory);
     if (directory === options.stopDir || parent === directory) {
       return { config: {} };
     }
@@ -1779,8 +2155,8 @@ function readPrettierFile(directory, stopDir) {
   let current = directory;
   for (; ; ) {
     for (const name of PRETTIER_FILES) {
-      const filepath = path2.join(current, name);
-      if (!existsSync(filepath)) {
+      const filepath = path3.join(current, name);
+      if (!existsSync2(filepath)) {
         continue;
       }
       const text = readFileSync2(filepath, "utf8");
@@ -1791,14 +2167,14 @@ function readPrettierFile(directory, stopDir) {
         tabWidth: tabWidth === void 0 ? void 0 : Number(tabWidth)
       };
     }
-    const packageJsonPath = path2.join(current, "package.json");
-    if (existsSync(packageJsonPath)) {
+    const packageJsonPath = path3.join(current, "package.json");
+    if (existsSync2(packageJsonPath)) {
       const prettier = readJson(packageJsonPath).prettier;
       if (prettier && typeof prettier === "object") {
         return prettier;
       }
     }
-    const parent = path2.dirname(current);
+    const parent = path3.dirname(current);
     if (current === stopDir || parent === current) {
       return void 0;
     }
@@ -1817,7 +2193,7 @@ var PrettierOptionsResolver = class {
       return this._prettier;
     }
     try {
-      const require2 = createRequire(path2.join(this._root, "package.json"));
+      const require2 = createRequire2(path3.join(this._root, "package.json"));
       const resolved = require2.resolve("prettier");
       this._prettier = await import(pathToFileURL(resolved).href);
     } catch {
@@ -1836,7 +2212,7 @@ var PrettierOptionsResolver = class {
       } catch {
       }
     }
-    const directory = path2.dirname(file);
+    const directory = path3.dirname(file);
     const cached = this._cache.get(directory);
     if (cached) {
       return cached;
@@ -1846,9 +2222,45 @@ var PrettierOptionsResolver = class {
     return options;
   }
 };
+var RUSTFMT_FILES = ["rustfmt.toml", ".rustfmt.toml"];
+var RUSTFMT_TAB_SPACES = 4;
+var RustfmtOptionsResolver = class {
+  constructor(_root) {
+    this._root = _root;
+  }
+  _root;
+  _cache = /* @__PURE__ */ new Map();
+  _read(directory) {
+    const cached = this._cache.get(directory);
+    if (cached) {
+      return cached;
+    }
+    let options;
+    for (const name of RUSTFMT_FILES) {
+      const filepath = path3.join(directory, name);
+      if (existsSync2(filepath)) {
+        const text = readFileSync2(filepath, "utf8");
+        const commentWidth = /^\s*comment_width\s*=\s*(\d+)/m.exec(text)?.[1];
+        const tabSpaces = /^\s*tab_spaces\s*=\s*(\d+)/m.exec(text)?.[1];
+        options = {
+          printWidth: commentWidth === void 0 ? void 0 : Number(commentWidth),
+          tabWidth: tabSpaces === void 0 ? RUSTFMT_TAB_SPACES : Number(tabSpaces)
+        };
+        break;
+      }
+    }
+    const parent = path3.dirname(directory);
+    options ??= directory === this._root || parent === directory ? { tabWidth: RUSTFMT_TAB_SPACES } : this._read(parent);
+    this._cache.set(directory, options);
+    return options;
+  }
+  resolve(file) {
+    return this._read(path3.dirname(file));
+  }
+};
 
 // src/comments/flow.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
 var DEFAULT_BATCH_SIZE = 20;
 var DEFAULT_MAX_FILES = 10;
 var DEFAULT_MAX_AGENTS = 6;
@@ -1876,6 +2288,11 @@ function needsAgent(comment) {
     (paragraph) => paragraph.issues.some((issue) => issue.tier === "hint" || paragraph.suggestion === null)
   );
 }
+var SELECTORS = {
+  suspicious: needsAgent,
+  failing: hasVerdictIssues,
+  all: () => true
+};
 function seconds(milliseconds) {
   return `${Math.round(milliseconds / 1e3)}s`;
 }
@@ -2020,9 +2437,9 @@ async function runFlow(project, scope, options) {
       skipped: skippedFiles(analyses)
     };
   }
+  const select2 = SELECTORS[options.select];
   const pending = analyses.map((analysis) => {
-    const selected = options.select === "all" ? analysis.comments : analysis.comments.filter((comment) => needsAgent(comment));
-    return { ...analysis, comments: selected };
+    return { ...analysis, comments: analysis.comments.filter((comment) => select2(comment)) };
   }).filter((analysis) => analysis.comments.length > 0);
   const comments = pending.flatMap((analysis) => analysis.comments);
   if (comments.length === 0) {
@@ -2090,7 +2507,7 @@ async function runFlow(project, scope, options) {
   const handedOver = new Set(pending.map((analysis) => analysis.file));
   const changedElsewhere = before && after ? changedBetween(before, after).filter((file) => !handedOver.has(file)) : [];
   const codeChanged = pending.filter((analysis) => {
-    if (!existsSync2(analysis.absolute)) {
+    if (!existsSync3(analysis.absolute)) {
       return true;
     }
     const current = readFileSync3(analysis.absolute, "utf8");
@@ -2147,7 +2564,7 @@ function describeSummary(summary) {
 import { spawnSync } from "child_process";
 import { createHash } from "crypto";
 import { readFileSync as readFileSync4, statSync } from "fs";
-import path3 from "path";
+import path4 from "path";
 function git(cwd, args) {
   const result = spawnSync("git", ["-c", "core.quotePath=false", ...args], {
     cwd,
@@ -2257,7 +2674,7 @@ function snapshotChanges(root) {
   try {
     const tracked = hasHead(root) ? splitPaths(gitOrThrow(root, ["diff", "-z", "--name-only", "--no-renames", "HEAD"])) : splitPaths(gitOrThrow(root, ["ls-files", "-z", "--cached"]));
     const files = /* @__PURE__ */ new Set([...tracked, ...listUntrackedFiles(root)]);
-    return new Map([...files].map((file) => [file, fileState(path3.join(root, file))]));
+    return new Map([...files].map((file) => [file, fileState(path4.join(root, file))]));
   } catch {
     return void 0;
   }
@@ -2276,15 +2693,15 @@ function getChangedLines(root, scope = {}) {
 }
 
 // src/comments/project.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import path4 from "path";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import path5 from "path";
 var DEFAULT_WIDTH = 80;
 var DEFAULT_MAX_WIDTH = 120;
 var DEFAULT_SINGLE_LINE_WIDTH = 120;
 var DEFAULT_TAB_WIDTH = 2;
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage"]);
 function toPosix(file) {
-  return file.split(path4.sep).join("/");
+  return file.split(path5.sep).join("/");
 }
 function mergeFilter(existing, next) {
   if (existing === "all" || next === "all") {
@@ -2297,10 +2714,10 @@ function walkDirectory(directory, files = []) {
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (!SKIPPED_DIRECTORIES.has(entry.name)) {
-        walkDirectory(path4.join(directory, entry.name), files);
+        walkDirectory(path5.join(directory, entry.name), files);
       }
     } else if (entry.isFile()) {
-      files.push(path4.join(directory, entry.name));
+      files.push(path5.join(directory, entry.name));
     }
   }
   return files;
@@ -2322,41 +2739,45 @@ var Project = class {
     this.config = config;
     this._options = _options;
     this._prettier = new PrettierOptionsResolver(root);
+    this._rustfmt = new RustfmtOptionsResolver(root);
     this._extensions = new Set(config.extensions ?? DEFAULT_EXTENSIONS);
   }
   root;
   config;
   _options;
   _prettier;
+  _rustfmt;
   _extensions;
   relative(absolute) {
-    return toPosix(path4.relative(this.root, absolute));
+    return toPosix(path5.relative(this.root, absolute));
   }
   _isIncluded(absolute) {
-    if (!this._extensions.has(path4.extname(absolute))) {
+    if (!this._extensions.has(path5.extname(absolute))) {
       return false;
     }
     const relative = this.relative(absolute);
-    return !(this.config.ignore ?? []).some((pattern) => path4.matchesGlob(relative, pattern));
+    const matches = (patterns) => patterns.some((pattern) => path5.matchesGlob(relative, pattern));
+    const include = this.config.include ?? [];
+    return (include.length === 0 || matches(include)) && !matches(this.config.ignore ?? []);
   }
   _filesIn(directory) {
     if (!this._options.isGitRepo) {
       return walkDirectory(directory);
     }
-    return listFiles2(this.root, [path4.relative(this.root, directory) || "."]).map((file) => path4.join(this.root, file));
+    return listFiles2(this.root, [path5.relative(this.root, directory) || "."]).map((file) => path5.join(this.root, file));
   }
   collect(scope) {
     const files = /* @__PURE__ */ new Map();
     const add = (absolute, filter) => {
-      if (this._isIncluded(absolute) && existsSync3(absolute)) {
+      if (this._isIncluded(absolute) && existsSync4(absolute)) {
         files.set(absolute, mergeFilter(files.get(absolute), filter));
       }
     };
     if (scope.targets && scope.targets.length > 0) {
       for (const target of scope.targets) {
         const range = /^(.+):(\d+)(?:-(\d+))?$/.exec(target);
-        const absolute = path4.resolve(this._options.cwd, range ? range[1] : target);
-        if (!existsSync3(absolute)) {
+        const absolute = path5.resolve(this._options.cwd, range ? range[1] : target);
+        if (!existsSync4(absolute)) {
           throw new Error(`comments: ${target} does not exist`);
         }
         if (statSync2(absolute).isDirectory()) {
@@ -2385,21 +2806,22 @@ var Project = class {
       throw new Error("comments: not a git repository, so pass files or directories explicitly");
     }
     for (const [file, lines] of getChangedLines(this.root, scope)) {
-      add(path4.join(this.root, file), scope.wholeFiles ? "all" : lines);
+      add(path5.join(this.root, file), scope.wholeFiles ? "all" : lines);
     }
     return files;
   }
   async analyzeFile(absolute, filter = "all") {
     const source = readFileSync5(absolute, "utf8");
-    const prettier = await this._prettier.resolve(absolute);
+    const isRust = absolute.endsWith(".rs");
+    const formatter = isRust ? this._rustfmt.resolve(absolute) : await this._prettier.resolve(absolute);
     const file = this.relative(absolute);
-    const width = this._options.width ?? this.config.width ?? prettier.printWidth ?? DEFAULT_WIDTH;
+    const width = this._options.width ?? this.config.width ?? formatter.printWidth ?? DEFAULT_WIDTH;
     const maxWidth = this.config.maxWidth ?? Math.max(width, this.config.tolerance === void 0 ? DEFAULT_MAX_WIDTH : width + this.config.tolerance);
     const { comments, syntaxError } = inspectSource(source, file, {
       width,
       maxWidth,
       singleLineWidth: this.config.singleLineWidth ?? DEFAULT_SINGLE_LINE_WIDTH,
-      tabWidth: prettier.tabWidth ?? DEFAULT_TAB_WIDTH,
+      tabWidth: formatter.tabWidth ?? DEFAULT_TAB_WIDTH,
       tolerance: Math.min(this.config.tolerance ?? 0, maxWidth - width),
       avoidSentenceOrphans: this.config.avoidSentenceOrphans ?? true,
       style: this.config.style ?? true
@@ -2882,7 +3304,7 @@ ${this._paint("gray", S_BAR_END)}  ${message}
 var HELP = `
 Usage: comments <command> [targets...] [options]
 
-Finds comments in JavaScript and TypeScript files and measures how their prose fits the configured width.
+Finds comments in JavaScript, TypeScript, and Rust files and measures how their prose fits the configured width.
 Only agent and hook change files, by applying the exact rewrap to comments that still have layout issues.
 
 Commands:
@@ -2902,6 +3324,7 @@ Options:
   --suspicious      Only comments with layout issues (overflow, early line ends, last lines of one or two words)
                     or hints (possible orphans, em-dashes, banners, ...). For agent and hook (the default), only
                     comments with hints or with issues in parts the tool never rewraps, a triage, not a full review
+  --failing         agent, hook: hand the agent only the comments that fail check, and none that only have hints
   --all             agent, hook: hand every comment in scope to the agent for a full review of its wording
   --verbose         agent, hook: print every agent's reply (otherwise a terminal offers to open them)
   --no-interactive  agent: show the agents while they run, then exit without offering to open their replies
@@ -2923,7 +3346,8 @@ Config overrides (take precedence over the config file):
                           with a sentence when the second is no longer than the first (default: on)
   --[no-]style            Look for possible semicolons, em-dashes, dashes, label colons, emphasis, and banners
                           as hints (default: on). The agent's rules apply either way
-  --ignore <glob>         Skip matching files, repeatable
+  --include <glob>        Only consider matching files, repeatable. Replaces include from the config file
+  --ignore <glob>         Skip matching files, repeatable. Adds to ignore from the config file
   --model <name>          agent, hook: model for the agent
   --timeout <seconds>     agent, hook: how long to wait for each agent (default: 300)
   --batch-size <n>        agent, hook: most comments per agent (default: 20)
@@ -2937,6 +3361,7 @@ var OPTIONS = {
   tolerance: { type: "string" },
   orphans: { type: "boolean" },
   style: { type: "boolean" },
+  include: { type: "string", multiple: true },
   ignore: { type: "string", multiple: true },
   model: { type: "string" },
   timeout: { type: "string" },
@@ -2948,6 +3373,7 @@ var OPTIONS = {
   "whole-files": { type: "boolean" },
   repo: { type: "boolean" },
   suspicious: { type: "boolean" },
+  failing: { type: "boolean" },
   all: { type: "boolean" },
   verbose: { type: "boolean" },
   interactive: { type: "boolean" },
@@ -2984,8 +3410,8 @@ function log2(message) {
 `);
 }
 function resolveCwd(directory, source = "--cwd") {
-  const resolved = path5.resolve(directory);
-  if (!existsSync4(resolved) || !statSync3(resolved).isDirectory()) {
+  const resolved = path6.resolve(directory);
+  if (!existsSync5(resolved) || !statSync3(resolved).isDirectory()) {
     throw new Error(`comments: ${source} ${directory} is not a directory`);
   }
   return realpathSync(resolved);
@@ -3011,6 +3437,7 @@ function applyOverrides(config, values) {
     tolerance: parseInteger("tolerance", values.tolerance, 0),
     avoidSentenceOrphans: values.orphans,
     style: values.style,
+    include: values.include,
     ignore: values.ignore ? [...config.ignore ?? [], ...values.ignore] : void 0
   });
   const agent = defined({
@@ -3035,10 +3462,11 @@ function scopeFrom(positionals, values) {
   return { targets: positionals, base: values.base, wholeFiles: values["whole-files"], repo: values.repo };
 }
 function selectFrom(values, project) {
-  if (values.all) {
-    return "all";
+  const flags = ["suspicious", "failing", "all"].filter((scope) => values[scope]);
+  if (flags.length > 1) {
+    throw new Error("comments: pass only one of --suspicious, --failing, and --all");
   }
-  return values.suspicious ? "suspicious" : project.config.agent?.scope ?? "suspicious";
+  return flags.at(0) ?? project.config.agent?.scope ?? "suspicious";
 }
 function formatIssue(issue) {
   return issue.tier === "hint" ? `${issue.type} (hint)` : issue.type;
@@ -3094,7 +3522,7 @@ function hintEmptyScope(analyses, scope) {
   const isDefaultScope = (scope.targets ?? []).length === 0 && !scope.repo && !scope.base;
   if (analyses.length === 0 && isDefaultScope) {
     log2(
-      "comments: no uncommitted changes in JavaScript or TypeScript files. Pass --repo, --base <ref>, or files to widen the scope."
+      "comments: no uncommitted changes in JavaScript, TypeScript, or Rust files. Pass --repo, --base <ref>, or files to widen the scope."
     );
   }
 }