agent-simple-english 0.7.0 → 0.8.0

package/src/engine/html.ts

@@ -2,16 +2,9 @@ import { parser as htmlParser } from "@lezer/html"
 import type { ExtractedComments, ProseBreak } from "./comments.ts"
 import type { MarkdownHtmlComment } from "./markdown.ts"
 
-// These elements hold code, markup, or preformatted content, never prose.
-// `code` is also inline, so a semicolon in inline code stays quiet while the
-// sentence around it still reads as one sentence.
-const IGNORED_CONTENT_TAGS = new Set(["code", "pre", "script", "style", "textarea"])
-
-// Phrasing elements that wrap words inside one sentence.
-// They never start a prose block, so a sentence split across them counts as one sentence.
-// Every other element starts a prose block.
-// That rule separates a heading, a list item, a table cell, and bare text in a `div`.
-const INLINE_TAGS = new Set([
+const NON_PROSE_CONTENT_TAGS = new Set(["code", "pre", "script", "style", "textarea"])
+
+const PHRASING_TAGS_INSIDE_ONE_SENTENCE = new Set([
   "a",
   "abbr",
   "b",
@@ -46,11 +39,7 @@ const INLINE_TAGS = new Set([
   "wbr",
 ])
 
-/**
- * Find every single-line HTML comment in the document with the lezer parser.
- * The markdown finder cannot see comments that markdown would read as indented code.
- */
-export function htmlComments(source: string): readonly MarkdownHtmlComment[] {
+export function singleLineHtmlComments(source: string): readonly MarkdownHtmlComment[] {
   const comments: MarkdownHtmlComment[] = []
   const lineStarts = [0]
   for (let offset = 0; offset < source.length; offset++) {
@@ -80,15 +69,9 @@ export function htmlComments(source: string): readonly MarkdownHtmlComment[] {
 
 interface OpenElement {
   readonly tag: string
-  readonly inline: boolean
+  readonly startsProseBlock: boolean
 }
 
-/**
- * Keep the text nodes of an HTML document and blank every other byte with a space.
- * Attribute values, comments, entity references, tags, and ignored element content all go.
- * Each prose block becomes one prose break, so sentences never join across a block edge.
- * The masked lines keep the width of the source lines, so positions stay exact.
- */
 export function extractHtmlProse(source: string): ExtractedComments {
   const keep = new Uint8Array(source.length)
   const blockEdges: number[] = []
@@ -103,10 +86,10 @@ export function extractHtmlProse(source: string): ExtractedComments {
           tagName === null || tagName === undefined
             ? ""
             : source.slice(tagName.from, tagName.to).toLowerCase()
-        const inline = INLINE_TAGS.has(tag)
-        if (!inline) blockEdges.push(ref.from)
-        if (IGNORED_CONTENT_TAGS.has(tag)) ignoreDepth += 1
-        open.push({ tag, inline })
+        const startsProseBlock = !PHRASING_TAGS_INSIDE_ONE_SENTENCE.has(tag)
+        if (startsProseBlock) blockEdges.push(ref.from)
+        if (NON_PROSE_CONTENT_TAGS.has(tag)) ignoreDepth += 1
+        open.push({ tag, startsProseBlock })
         return
       }
       if (ref.name === "Text" && ignoreDepth === 0) keep.fill(1, ref.from, ref.to)
@@ -115,8 +98,8 @@ export function extractHtmlProse(source: string): ExtractedComments {
       if (ref.name !== "Element") return
       const element = open.pop()
       if (element === undefined) return
-      if (IGNORED_CONTENT_TAGS.has(element.tag)) ignoreDepth -= 1
-      if (!element.inline) blockEdges.push(ref.to)
+      if (NON_PROSE_CONTENT_TAGS.has(element.tag)) ignoreDepth -= 1
+      if (element.startsProseBlock) blockEdges.push(ref.to)
     },
   })
 

package/src/engine/identifiers.ts

@@ -1,20 +1,23 @@
-// A token is exempt as an identifier when it has an interior signal prose
-// words lack: a camelCase hump, an underscore, a dotted or :: path, or a
-// call suffix. Mixed-case prose words (brand names) are an accepted loss.
 const IDENTIFIER_CANDIDATE =
   /[A-Za-z_$][\w$]*(?:(?:\.|::)(?:[A-Za-z$][\w$]*|_+[A-Za-z0-9$][\w$]*))*(?:\(\))?/g
 
-const isIdentifier = (token: string): boolean =>
-  token.endsWith("()") ||
-  token.includes(".") ||
-  token.includes("::") ||
-  /[a-z][A-Z]/.test(token) ||
-  /[A-Za-z0-9$]_[A-Za-z0-9_$]/.test(token)
+const hasCallSuffix = (token: string): boolean => token.endsWith("()")
+const hasDottedPath = (token: string): boolean => token.includes(".")
+const hasScopePath = (token: string): boolean => token.includes("::")
+const hasCamelCaseHump = (token: string): boolean => /[a-z][A-Z]/.test(token)
+const hasInteriorUnderscore = (token: string): boolean => /[A-Za-z0-9$]_[A-Za-z0-9_$]/.test(token)
+
+const hasSignalThatProseWordsLack = (token: string): boolean =>
+  hasCallSuffix(token) ||
+  hasDottedPath(token) ||
+  hasScopePath(token) ||
+  hasCamelCaseHump(token) ||
+  hasInteriorUnderscore(token)
 
 export function blankIdentifiers(lines: readonly string[]): string[] {
   return lines.map((line) =>
     line.replace(IDENTIFIER_CANDIDATE, (match) =>
-      isIdentifier(match) ? " ".repeat(match.length) : match,
+      hasSignalThatProseWordsLack(match) ? " ".repeat(match.length) : match,
     ),
   )
 }

package/src/engine/kinds.ts

@@ -7,9 +7,7 @@ export interface PathClassification {
 }
 
 const PROSE: PathClassification = { kind: "prose-file", sourceDialect: "general" }
-// Data and style files carry rules and structured data rather than prose,
-// so the writing rules would misread them as sentences (HUF-308).
-const SKIPPED: PathClassification = { ...PROSE, skipped: true }
+const DATA_OR_STYLE_NOT_PROSE: PathClassification = { ...PROSE, skipped: true }
 const HTML: PathClassification = { kind: "html", sourceDialect: "general" }
 
 const slash = (sourceDialect: SourceDialect): PathClassification => ({
@@ -51,17 +49,17 @@ const BY_EXTENSION: Readonly<Record<string, PathClassification>> = {
   toml: hash("general"),
   html: HTML,
   htm: HTML,
-  css: SKIPPED,
-  scss: SKIPPED,
-  less: SKIPPED,
-  json: SKIPPED,
-  jsonc: SKIPPED,
-  svg: SKIPPED,
-  xml: SKIPPED,
-  typ: SKIPPED,
-  csv: SKIPPED,
-  tsv: SKIPPED,
-  lock: SKIPPED,
+  css: DATA_OR_STYLE_NOT_PROSE,
+  scss: DATA_OR_STYLE_NOT_PROSE,
+  less: DATA_OR_STYLE_NOT_PROSE,
+  json: DATA_OR_STYLE_NOT_PROSE,
+  jsonc: DATA_OR_STYLE_NOT_PROSE,
+  svg: DATA_OR_STYLE_NOT_PROSE,
+  xml: DATA_OR_STYLE_NOT_PROSE,
+  typ: DATA_OR_STYLE_NOT_PROSE,
+  csv: DATA_OR_STYLE_NOT_PROSE,
+  tsv: DATA_OR_STYLE_NOT_PROSE,
+  lock: DATA_OR_STYLE_NOT_PROSE,
 }
 
 export const classifyPath = (path: string): PathClassification => {

package/src/engine/lint.ts

@@ -10,8 +10,8 @@ import { retainedRanges } from "./diff.ts"
 import { newFindings, type ScopedViolation, type ViolationScope } from "./diff-match.ts"
 import { extractHtmlProse } from "./html.ts"
 import { blankIdentifiers } from "./identifiers.ts"
-import { type BlockStructure, blankMarkdownForLint } from "./markdown.ts"
-import { type Paragraph, segmentParagraphs } from "./paragraphs.ts"
+import { type BlockStructure, blankMarkdownForLint, type SentenceBoundary } from "./markdown.ts"
+import { type Paragraph, segmentParagraphsByLeafBlock } from "./paragraphs.ts"
 import { contraction } from "./rules/contraction.ts"
 import { type CompiledDictionary, compileDictionary, dictionaryRule } from "./rules/dictionary.ts"
 import { hedging } from "./rules/hedging.ts"
@@ -65,7 +65,7 @@ interface PreparedProse {
   readonly wordingStructuralLines: readonly string[]
   readonly structuralBlanks: readonly boolean[]
   readonly wordingStructuralBlanks: readonly boolean[]
-  readonly sentenceBoundaryLines: readonly boolean[]
+  readonly sentenceBoundaryLines: readonly SentenceBoundary[]
   readonly blocks: BlockStructure
 }
 
@@ -296,15 +296,16 @@ const lintProse = (
     prepared.boundaryLines,
     prepared.sentenceBoundaryLines,
   )
-  const paragraphs = segmentParagraphs(
+  const paragraphs = segmentParagraphsByLeafBlock(
     prepared.structuralLines.map((line, index) => line.slice(contentStarts[index] ?? 0)),
     contentStarts.map((contentStart) => contentStart + 1),
     prepared.structuralBoundaryLines.map((line, index) => line.slice(contentStarts[index] ?? 0)),
     {
-      ids: prepared.blocks.ids,
-      contentStarts: prepared.blocks.contentStarts.map(
-        (contentStart, index) => contentStart - (contentStarts[index] ?? 0),
-      ),
+      leafBlockIdByLine: prepared.blocks.leafBlockIdByLine,
+      contentStartAfterContainerPrefixByLine:
+        prepared.blocks.contentStartAfterContainerPrefixByLine.map(
+          (contentStart, index) => contentStart - (contentStarts[index] ?? 0),
+        ),
     },
   )
   const offsets = lineOffsets(prepared.structuralLines)

package/src/engine/markdown-syntax.ts

@@ -1,3 +1,4 @@
+import { list } from "micromark-core-commonmark"
 import {
   asciiAlpha,
   asciiAlphanumeric,
@@ -163,9 +164,20 @@ const rawHtmlFlow: Construct = {
   tokenize: tokenizeRawHtmlFlow,
 }
 
+const orderedListAfterParagraph: Construct = {
+  ...list,
+  tokenize(this: TokenizeContext, effects: Effects, ok: State, nok: State): State {
+    const context: TokenizeContext = Object.create(this, { interrupt: { value: false } })
+    return list.tokenize.call(context, effects, ok, nok)
+  },
+}
+
 export const markdownSyntaxExtension: Extension = {
   disable: {
     null: ["labelEnd", "labelStartImage", "labelStartLink"],
   },
+  document: Object.fromEntries(
+    Array.from({ length: 10 }, (_, digit) => [48 + digit, orderedListAfterParagraph]),
+  ),
   flow: { 60: rawHtmlFlow },
 }

package/src/engine/markdown.ts

@@ -16,15 +16,17 @@ interface MarkdownAnalysis {
   readonly wordingDictionaryLines: string[]
   readonly structuralBlanks: boolean[]
   readonly wordingStructuralBlanks: boolean[]
-  readonly sentenceBoundaryLines: boolean[]
+  readonly sentenceBoundaryLines: SentenceBoundary[]
   readonly blocks: BlockStructure
 }
 
-// Per line: the id of the leaf block that owns it, or -1 when no block does, and
-// the column where the block content starts after any quote or list prefix.
+export type SentenceBoundary = "none" | "stops-lookahead" | "starts-sentence"
+
+export const NO_LEAF_BLOCK = -1
+
 export interface BlockStructure {
-  readonly ids: readonly number[]
-  readonly contentStarts: readonly number[]
+  readonly leafBlockIdByLine: readonly number[]
+  readonly contentStartAfterContainerPrefixByLine: readonly number[]
 }
 
 interface AnalysisState {
@@ -39,7 +41,7 @@ interface AnalysisState {
   readonly blockQuoteMask: Uint8Array | undefined
   readonly blockQuoteLines: Uint8Array | undefined
   readonly structuralBlanks: boolean[]
-  readonly sentenceBoundaryLines: boolean[]
+  readonly sentenceBoundaryLines: SentenceBoundary[]
   readonly blockIds: number[]
   readonly blockContentStarts: number[]
 }
@@ -155,8 +157,6 @@ const SENTENCE_BOUNDARY_TOKENS = new Set([
   "thematicBreak",
 ])
 const CONTAINER_TOKENS = new Set(["blockQuotePrefix", "listItemIndent", "listItemPrefix"])
-// One leaf block per line group. Every rule reads block structure from these ids,
-// so no rule needs its own Markdown classifier.
 const LEAF_BLOCK_TOKENS = new Set([
   "atxHeading",
   "codeFenced",
@@ -238,8 +238,8 @@ const createAnalysisState = (
     blockQuoteMask: exemptBlockQuotes ? new Uint8Array(source.length) : undefined,
     blockQuoteLines: exemptBlockQuotes ? new Uint8Array(parseLines.length) : undefined,
     structuralBlanks: parseLines.map((line) => line.trim() === ""),
-    sentenceBoundaryLines: parseLines.map(() => false),
-    blockIds: parseLines.map(() => -1),
+    sentenceBoundaryLines: parseLines.map(() => "none"),
+    blockIds: parseLines.map(() => NO_LEAF_BLOCK),
     blockContentStarts: parseLines.map(() => 0),
   }
 }
@@ -472,8 +472,14 @@ const analyzeEvents = (state: AnalysisState, includeDictionary: boolean): void =
     }
     if (phase !== "enter") continue
 
-    if (SENTENCE_BOUNDARY_TOKENS.has(token.type)) {
-      state.sentenceBoundaryLines[token.start.line - 1] = true
+    const line = token.start.line - 1
+    if (token.type === "listItemPrefix") {
+      state.sentenceBoundaryLines[line] = "starts-sentence"
+    } else if (
+      SENTENCE_BOUNDARY_TOKENS.has(token.type) &&
+      state.sentenceBoundaryLines[line] === "none"
+    ) {
+      state.sentenceBoundaryLines[line] = "stops-lookahead"
     }
     if (LEAF_BLOCK_TOKENS.has(token.type)) {
       markLeafBlock(state, token, nextBlockId++)
@@ -483,7 +489,6 @@ const analyzeEvents = (state: AnalysisState, includeDictionary: boolean): void =
       continue
     }
     if (CONTAINER_TOKENS.has(token.type)) {
-      const line = token.start.line - 1
       state.blockContentStarts[line] = Math.max(
         state.blockContentStarts[line] ?? 0,
         token.end.column - 1,
@@ -559,7 +564,7 @@ const analyzeMarkdown = (
       structuralBlanks: [],
       wordingStructuralBlanks: [],
       sentenceBoundaryLines: [],
-      blocks: { ids: [], contentStarts: [] },
+      blocks: { leafBlockIdByLine: [], contentStartAfterContainerPrefixByLine: [] },
     }
   }
 
@@ -634,8 +639,8 @@ const analyzeMarkdown = (
           ),
     sentenceBoundaryLines: state.sentenceBoundaryLines,
     blocks: {
-      ids: state.blockIds,
-      contentStarts: state.blockContentStarts.map(
+      leafBlockIdByLine: state.blockIds,
+      contentStartAfterContainerPrefixByLine: state.blockContentStarts.map(
         (contentStart, index) => (starts[index] ?? 0) + contentStart,
       ),
     },

package/src/engine/paragraphs.ts

@@ -1,4 +1,4 @@
-import type { BlockStructure } from "./markdown.ts"
+import { type BlockStructure, NO_LEAF_BLOCK } from "./markdown.ts"
 
 export interface Paragraph {
   readonly lines: readonly string[]
@@ -15,9 +15,7 @@ interface OpenParagraph {
   readonly boundaryLines: string[]
 }
 
-// One paragraph per Markdown leaf block. Each line drops the quote and list
-// prefix that the block parser found, so a rule reads block content only.
-export function segmentParagraphs(
+export function segmentParagraphsByLeafBlock(
   lines: readonly string[],
   columns: readonly number[],
   boundaryLines: readonly string[],
@@ -32,7 +30,7 @@ export function segmentParagraphs(
   }
 
   lines.forEach((raw, index) => {
-    const blockId = blocks.ids[index] ?? -1
+    const blockId = blocks.leafBlockIdByLine[index] ?? NO_LEAF_BLOCK
     if (blockId < 0) {
       close()
       return
@@ -48,7 +46,7 @@ export function segmentParagraphs(
       }
     }
 
-    const contentStart = blocks.contentStarts[index] ?? 0
+    const contentStart = blocks.contentStartAfterContainerPrefixByLine[index] ?? 0
     open.lines.push(raw.slice(contentStart))
     open.boundaryLines.push((boundaryLines[index] ?? raw).slice(contentStart))
   })

package/src/engine/phrase-matcher.ts

@@ -35,16 +35,17 @@ export interface PhraseMatch {
   readonly tokenCount: number
 }
 
-// Longest phrase first when callers sort their list that way.
-export function matchPhraseAt(
+export function matchFirstListedPhraseAt(
   line: string,
   tokens: readonly CaseFoldedToken[],
   start: number,
-  phrases: readonly CaseFoldedPhrase[],
+  phrasesInPriorityOrder: readonly CaseFoldedPhrase[],
 ): PhraseMatch | undefined {
   const first = tokens[start]
   if (first === undefined) return undefined
-  const phrase = phrases.find((candidate) => matchesPhrase(line, tokens, start, candidate))
+  const phrase = phrasesInPriorityOrder.find((candidate) =>
+    matchesPhrase(line, tokens, start, candidate),
+  )
   if (phrase === undefined) return undefined
   const last = tokens[start + phrase.words.length - 1]
   if (last === undefined) return undefined
@@ -67,7 +68,7 @@ export function scanCaseFoldedPhrases(
 
     const tokens = tokenizeCaseFolded(line)
     for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex++) {
-      const match = matchPhraseAt(line, tokens, tokenIndex, phrases)
+      const match = matchFirstListedPhraseAt(line, tokens, tokenIndex, phrases)
       if (match === undefined) continue
       matches.push({ found: match.found, line: lineIndex + 1, column: match.offset + 1 })
       tokenIndex += match.tokenCount - 1

package/src/engine/rules/contraction.ts

@@ -4,13 +4,14 @@ import { DEFAULT_SEVERITIES } from "./registry.ts"
 
 const CONTRACTION = /\b\w+['’](?:t|re|ve|ll|d|m)\b/gi
 
-// `'s` is the only ambiguous case: "repo's" is a possessive, not a
-// contraction, so only this fixed set of stems forms a real `'s` contraction.
-const CONTRACTION_S =
+const S_CONTRACTION_OF_STEM_THAT_IS_NEVER_POSSESSIVE =
   /\b(?:it|he|she|that|what|who|there|here|let|one|where|how|everyone|everybody|something|nothing|somebody|nobody)['’]s\b/gi
 
 export function contraction(lines: readonly string[]): Violation[] {
-  return [...scanLines(lines, CONTRACTION), ...scanLines(lines, CONTRACTION_S)].map((match) => ({
+  return [
+    ...scanLines(lines, CONTRACTION),
+    ...scanLines(lines, S_CONTRACTION_OF_STEM_THAT_IS_NEVER_POSSESSIVE),
+  ].map((match) => ({
     ruleId: "contraction",
     severity: DEFAULT_SEVERITIES.contraction,
     message: `Do not use a contraction. Write the words in full. Found "${match.found}".`,

package/src/engine/rules/dictionary.ts

@@ -1,6 +1,6 @@
 import { DICTIONARY_TOKEN_SOURCE } from "../../dictionary/form.ts"
 import type { Dictionary, DictionaryData, DictionaryEntry } from "../../dictionary/schema.ts"
-import type { BlockStructure } from "../markdown.ts"
+import { type BlockStructure, NO_LEAF_BLOCK } from "../markdown.ts"
 import type { TaggedToken, Tagger } from "../tagger.ts"
 import type { Violation } from "../types.ts"
 import { DEFAULT_SEVERITIES } from "./registry.ts"
@@ -48,8 +48,7 @@ export const compileDictionary = (dictionary: DictionaryData): CompiledDictionar
       }
     : { mode: "not-approved", forms: compileForms(dictionary) }
 
-// Two words join across a line break only inside one Markdown leaf block.
-const isSoftLineBreak = (
+const isLineBreakInsideOneLeafBlock = (
   lines: readonly string[],
   blocks: BlockStructure,
   previous: WordToken,
@@ -64,14 +63,17 @@ const isSoftLineBreak = (
     return false
   }
 
-  const previousBlock = blocks.ids[previous.lineIndex] ?? -1
-  if (previousBlock < 0 || previousBlock !== blocks.ids[token.lineIndex]) {
+  const previousBlock = blocks.leafBlockIdByLine[previous.lineIndex] ?? NO_LEAF_BLOCK
+  if (previousBlock < 0 || previousBlock !== blocks.leafBlockIdByLine[token.lineIndex]) {
     return false
   }
 
   const lineEnd = previousLine.endsWith("\r") ? previousLine.length - 1 : previousLine.length
   const trailing = previousLine.slice(previous.offset + previous.text.length, lineEnd)
-  const leading = nextLine.slice(blocks.contentStarts[token.lineIndex] ?? 0, token.offset)
+  const leading = nextLine.slice(
+    blocks.contentStartAfterContainerPrefixByLine[token.lineIndex] ?? 0,
+    token.offset,
+  )
   return (trailing === "" || trailing === " ") && /^[\t ]*$/.test(leading)
 }
 
@@ -101,7 +103,7 @@ const hasWords = (
         /^\s+$/.test(line.slice(previous.offset + previous.text.length, token.offset))
       )
     }
-    return isSoftLineBreak(lines, blocks, previous, token)
+    return isLineBreakInsideOneLeafBlock(lines, blocks, previous, token)
   })
 
 const hasPartOfSpeech = (

package/src/engine/rules/marketing.ts

@@ -3,7 +3,7 @@ import { type CaseFoldedToken, caseFoldKey, tokenizeCaseFolded } from "../case-f
 import {
   type CaseFoldedPhrase,
   compileCaseFoldedPhrase,
-  matchPhraseAt,
+  matchFirstListedPhraseAt,
   type PhraseMatch,
 } from "../phrase-matcher.ts"
 import type { Violation } from "../types.ts"
@@ -32,8 +32,7 @@ const marketingDataFor = (dictionary: Dictionary): CompiledMarketingData => {
   return compiled
 }
 
-// A listed single word inside a hyphenated token ("world-class-ready") still counts.
-function findMarketingComponent(
+function findListedWordInsideHyphenatedToken(
   token: CaseFoldedToken,
   componentWords: ReadonlySet<string>,
 ): PhraseMatch | undefined {
@@ -60,8 +59,8 @@ export function marketing(lines: readonly string[], dictionary: Dictionary): Vio
       if (token === undefined) continue
 
       const match =
-        matchPhraseAt(line, tokens, tokenIndex, data.phrases) ??
-        findMarketingComponent(token, data.componentWords)
+        matchFirstListedPhraseAt(line, tokens, tokenIndex, data.phrases) ??
+        findListedWordInsideHyphenatedToken(token, data.componentWords)
       if (match === undefined) continue
 
       violations.push({

package/src/engine/rules/verb-form.ts

@@ -10,17 +10,13 @@ const isBeForm = (token: TaggedToken) => BE_FORMS.has(token.text.toLowerCase())
 
 const isPerfectAuxiliary = (token: TaggedToken) => token.pos === "AUX" && token.lemma === "have"
 
-// Adverbs and "not" may sit between the auxiliary and its verb
-// ("was quickly closed", "were not shown") without breaking the construct.
-const isSkippable = (token: TaggedToken) =>
+const maySitBetweenAuxiliaryAndVerb = (token: TaggedToken) =>
   token.pos === "ADV" || token.text.toLowerCase() === "not"
 
 const isProgressiveVerb = (token: TaggedToken) =>
   token.pos === "VERB" && token.text.toLowerCase().endsWith("ing")
 
-// After a be/have auxiliary, any non-"ing" verb is a past participle in
-// practice, which covers irregular forms (broken, sent, written) without a list.
-const isPastParticiple = (token: TaggedToken) =>
+const isNonProgressiveVerbAfterAuxiliary = (token: TaggedToken) =>
   token.pos === "VERB" && !token.text.toLowerCase().endsWith("ing")
 
 const allowlistByDictionary = new WeakMap<Dictionary, ReadonlySet<string>>()
@@ -42,7 +38,7 @@ const isAllowlisted = (token: TaggedToken, dictionary: Dictionary | undefined):
 function nextContentToken(tokens: readonly TaggedToken[], start: number): TaggedToken | undefined {
   for (let i = start; i < tokens.length; i++) {
     const token = tokens[i]
-    if (token !== undefined && !isSkippable(token)) {
+    if (token !== undefined && !maySitBetweenAuxiliaryAndVerb(token)) {
       return token
     }
   }
@@ -78,14 +74,14 @@ export function verbForm(
           message: `Use a simple tense. Do not use the progressive. Found: "${found}".`,
           ...position,
         })
-      } else if (isBeForm(token) && isPastParticiple(head) && !allowlisted) {
+      } else if (isBeForm(token) && isNonProgressiveVerbAfterAuxiliary(head) && !allowlisted) {
         violations.push({
           ruleId: "verb-passive",
           severity: DEFAULT_SEVERITIES["verb-passive"],
           message: `Use the active voice, unless the actor is unknown. Found: "${found}".`,
           ...position,
         })
-      } else if (isPerfectAuxiliary(token) && isPastParticiple(head)) {
+      } else if (isPerfectAuxiliary(token) && isNonProgressiveVerbAfterAuxiliary(head)) {
         violations.push({
           ruleId: "verb-perfect",
           severity: DEFAULT_SEVERITIES["verb-perfect"],

package/src/engine/sentences.ts

@@ -1,3 +1,5 @@
+import type { SentenceBoundary } from "./markdown.ts"
+
 export interface Sentence {
   readonly text: string
   readonly line: number
@@ -337,9 +339,7 @@ function abbreviationIsInternal(
   return isInitial
 }
 
-// Identifier masking blanks dotted abbreviations but leaves their final periods.
-// Restore only listed abbreviations from the equal-length pre-identifier line.
-function restoreAbbreviations(
+function restoreListedAbbreviationsThatIdentifierMaskingBlanked(
   text: string,
   boundaryLine: string,
   boundaryText: string,
@@ -451,15 +451,12 @@ function sentenceTerminatorEnds(
   return ends
 }
 
-// A sentence starts at the first non-whitespace character and ends at
-// terminal punctuation and closing delimiters, at a blank line, or at EOF.
-// Sentences may span lines; position is where the sentence starts (1-based).
 export function segmentSentences(
   lines: readonly string[],
   sourceText: string = lines.join("\n"),
   structuralBlanks: readonly boolean[] = lines.map((line) => line.trim() === ""),
   boundaryLines: readonly string[] = lines,
-  sentenceBoundaryLines: readonly boolean[] = lines.map(() => false),
+  sentenceBoundaryLines: readonly SentenceBoundary[] = lines.map(() => "none"),
 ): Sentence[] {
   const sentences: Sentence[] = []
   const lineOffsets = [0]
@@ -472,7 +469,8 @@ export function segmentSentences(
   const boundaryOffsets: number[] = []
   const paragraphEnds: number[] = []
   const lookaheadBreaks = lines.map(
-    (_line, index) => (structuralBlanks[index] ?? true) || (sentenceBoundaryLines[index] ?? false),
+    (_line, index) =>
+      (structuralBlanks[index] ?? true) || (sentenceBoundaryLines[index] ?? "none") !== "none",
   )
   let boundaryOffset = 0
   for (const line of effectiveBoundaryLines) {
@@ -524,13 +522,14 @@ export function segmentSentences(
   }
 
   lines.forEach((maskedRaw, index) => {
+    if (sentenceBoundaryLines[index] === "starts-sentence") close()
     if (maskedRaw.trim() === "") {
       if (structuralBlanks[index] ?? true) close()
       return
     }
     const boundaryRaw = effectiveBoundaryLines[index] ?? maskedRaw
     const currentBoundaryOffset = boundaryOffsets[index] ?? 0
-    const raw = restoreAbbreviations(
+    const raw = restoreListedAbbreviationsThatIdentifierMaskingBlanked(
       maskedRaw,
       boundaryRaw,
       boundaryText,

package/src/engine/suppression.ts

@@ -1,6 +1,6 @@
 import type { LineCommentSpan } from "./comments.ts"
 import type { ScopedViolation } from "./diff-match.ts"
-import { htmlComments } from "./html.ts"
+import { singleLineHtmlComments } from "./html.ts"
 import { type MarkdownHtmlComment, markdownHtmlComments } from "./markdown.ts"
 import { DEFAULT_SEVERITIES, type RuleId, ruleIds } from "./rules/registry.ts"
 import { lineOffsets } from "./scan.ts"
@@ -135,7 +135,7 @@ export function analyzeSuppressions(
     kind === "prose-file"
       ? commentCandidates(markdownHtmlComments(text))
       : kind === "html"
-        ? commentCandidates(htmlComments(text))
+        ? commentCandidates(singleLineHtmlComments(text))
         : kind === "slash-source" || kind === "hash-source"
           ? sourceCandidates(lines, lineComments)
           : []

package/src/engine/types.ts

@@ -37,15 +37,8 @@ export interface LintOptions {
   readonly exemptBlockQuotes?: boolean
   readonly dictionary?: DictionaryData
   readonly ruleData?: RuleData
-  // POS tagger for the verb-form rules and POS-aware dictionary entries.
   readonly tagger?: Tagger
   readonly sourceDialect?: SourceDialect
-  /**
-   * The previous document text used to report only new violations.
-   * The engine compares sentence-scoped and paragraph-scoped violations structurally.
-   * Omit this value to lint the current document in full.
-   * Violation positions refer to the current text.
-   */
   readonly previousText?: string
 }
 

package/src/extension/index.ts

@@ -237,24 +237,6 @@ function enforceStrictEvent(state: SessionState, eventValue: unknown): void {
   }
 }
 
-// Strict mode must have the last word on user-facing text, and the public hooks cannot give it.
-// `emit` drops handler results for every event except `session_before_*` (pi
-// dist/core/extensions/runner.js:623-652), and `message_end` and `tool_result` chain
-// last-writer-wins in extension load order (pi docs/extensions.md:848-851). No `pi.on` overload
-// takes a priority, so a later extension can restore prose that this extension removed.
-// These patches run after the whole handler loop, which is the only remaining seam.
-//
-// Four assumptions hold this together, and each one fails silently.
-// `test/extension/extension.test.ts` guards them:
-// 1. pi still calls `emit`, `emitMessageEnd`, and `emitToolResult`. A rename leaves the patch on
-//    the prototype, but pi never invokes it, and redaction stops with no error.
-// 2. The extension and the host share one `ExtensionRunner` class object. The pi loader aliases
-//    the package specifier to the module the host runs, so this prototype is the live one.
-// 3. `createContext().sessionManager` keeps a stable identity, because it is the WeakMap key.
-//    A per-call wrapper makes every lookup miss.
-// 4. `pi.on("tool_result")` stays registered. AgentSession gates the call behind
-//    `hasHandlers("tool_result")` (pi dist/core/agent-session.js:246), so a drop of that handler
-//    makes the `emitToolResult` patch dead.
 function installStrictOutputBoundary(): void {
   if (boundaryRegistry.installed) return
   boundaryRegistry.installed = true