agent-simple-english 0.5.0 → 0.5.1

package/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
     {
       "name": "simple-english",
       "description": "Apply technical and house-style writing rules to writes, edits, and git commit messages.",
-      "version": "0.5.0",
+      "version": "0.5.1",
       "author": {
         "name": "JIA YI"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "simple-english",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Apply technical and house-style writing rules to writes, edits, and git commit messages.",
   "repository": "https://github.com/jyooi/agent-simple-english",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-simple-english",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Technical and house-style English lint engine, CLI, and host adapters",
   "license": "MIT",
   "type": "module",
@@ -54,7 +54,6 @@
     "micromark-util-html-tag-name": "^2.0.1",
     "micromark-util-normalize-identifier": "^2.0.1",
     "micromark-util-types": "^2.0.2",
-    "unicode-case-folding": "^1.1.1",
     "wink-eng-lite-web-model": "^1.8.1",
     "wink-nlp": "^2.4.0"
   },

package/src/adapter/feedback.ts

@@ -2,7 +2,6 @@ import type { RuleId } from "../engine/rules/registry.ts"
 import type { Violation } from "../engine/types.ts"
 
 function suggestedFix(violation: Violation): string {
-  if (violation.suggestion !== undefined) return `Use "${violation.suggestion}".`
   if (violation.suggestions !== undefined && violation.suggestions.length > 0) {
     return `Use one of these approved alternatives: ${violation.suggestions.map((item) => `"${item}"`).join(", ")}.`
   }
@@ -39,3 +38,12 @@ export function formatViolations(
 ): string {
   return `${heading} ${path}:\n${violationDetails(violations)}`
 }
+
+export function splitViolations<V extends Violation>(
+  violations: readonly V[],
+): { readonly hard: V[]; readonly soft: V[] } {
+  return {
+    hard: violations.filter((violation) => violation.severity === "hard"),
+    soft: violations.filter((violation) => violation.severity === "soft"),
+  }
+}

package/src/cli/hook.ts

@@ -3,7 +3,7 @@ import { open, readFile } from "node:fs/promises"
 import { resolve } from "node:path"
 import { Cause, Effect } from "effect"
 import { blankCommitMetadata, findCommitInvocations } from "../adapter/commit-message.ts"
-import { formatViolations } from "../adapter/feedback.ts"
+import { formatViolations, splitViolations } from "../adapter/feedback.ts"
 import { ruleSummary } from "../adapter/rule-summary.ts"
 import { loadConfig } from "../config/load.ts"
 import { loadConfiguredDictionary } from "../dictionary/configured.ts"
@@ -24,6 +24,7 @@ import {
   hasProcessedReply,
   setReplyFeedback,
 } from "./session-state.ts"
+import { tryAsync } from "./try-async.ts"
 
 interface CommonEvent {
   readonly cwd: string
@@ -244,49 +245,13 @@ function proposedEdit(
 }
 
 const readEditFile = (path: string) =>
-  Effect.tryPromise({
-    try: () => readFile(path, "utf8"),
-    catch: (cause) => new Error(`cannot read edit file ${path}: ${cause}`),
-  })
+  tryAsync(`cannot read edit file ${path}`, () => readFile(path, "utf8"))
 
 interface AssistantReply {
   readonly identity: string
   readonly text: string
 }
 
-function assistantReply(line: string, path: string, offset: number): AssistantReply | undefined {
-  let value: unknown
-  try {
-    value = JSON.parse(line) as unknown
-  } catch {
-    return undefined
-  }
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined
-  const entry = value as Record<string, unknown>
-  if (entry.type !== "assistant") return undefined
-  const message = record(entry.message, "assistant transcript message")
-  const content = message.content
-  if (!Array.isArray(content)) {
-    throw new Error(`assistant transcript message in ${path} must contain content blocks`)
-  }
-  const uuid = entry.uuid
-  const identity =
-    typeof uuid === "string" && uuid.length > 0
-      ? `uuid:${uuid}`
-      : `offset:${offset}:${createHash("sha256").update(line).digest("hex")}`
-  const text = content
-    .filter(
-      (block): block is { type: "text"; text: string } =>
-        typeof block === "object" &&
-        block !== null &&
-        (block as Record<string, unknown>).type === "text" &&
-        typeof (block as Record<string, unknown>).text === "string",
-    )
-    .map((block) => block.text)
-    .join("\n")
-  return { identity, text }
-}
-
 const TRANSCRIPT_CHUNK_SIZE = 64 * 1024
 const TRANSCRIPT_ENTRY_HEADER_SIZE = 64 * 1024
 
@@ -384,23 +349,6 @@ async function readTranscriptRange(
   return buffer
 }
 
-async function assistantReplyInRange(
-  file: Awaited<ReturnType<typeof open>>,
-  path: string,
-  start: number,
-  end: number,
-): Promise<AssistantReply | undefined> {
-  const length = end - start
-  const headerLength = Math.min(length, TRANSCRIPT_ENTRY_HEADER_SIZE)
-  const header = await readTranscriptRange(file, path, start, headerLength)
-  if (transcriptEntryKind(header.toString("utf8")) !== "assistant") return undefined
-  const line =
-    headerLength === length
-      ? header.toString("utf8")
-      : (await readTranscriptRange(file, path, start, length)).toString("utf8")
-  return assistantReply(line, path, start)
-}
-
 async function turnIdentityInRange(
   file: Awaited<ReturnType<typeof open>>,
   path: string,
@@ -464,12 +412,6 @@ async function latestTranscriptEntry<T>(
   }
 }
 
-async function assistantReplyFromTranscript(path: string): Promise<AssistantReply> {
-  const reply = await latestTranscriptEntry(path, assistantReplyInRange)
-  if (reply !== undefined) return reply
-  throw new Error(`cannot find an assistant reply in ${path}`)
-}
-
 async function assistantReplyFromEvent(text: string, path: string): Promise<AssistantReply> {
   const turnIdentity = await latestTranscriptEntry(path, turnIdentityInRange)
   if (turnIdentity === undefined) throw new Error(`cannot find a reply turn in ${path}`)
@@ -477,45 +419,28 @@ async function assistantReplyFromEvent(text: string, path: string): Promise<Assi
   return { identity: `${turnIdentity}:reply:${textHash}`, text }
 }
 
-const readAssistantReply = (path: string) =>
-  Effect.tryPromise({
-    try: () => assistantReplyFromTranscript(path),
-    catch: (cause) => new Error(`cannot read assistant reply from ${path}: ${cause}`),
-  })
-
 const readEventAssistantReply = (text: string, path: string) =>
-  Effect.tryPromise({
-    try: () => assistantReplyFromEvent(text, path),
-    catch: (cause) => new Error(`cannot read assistant reply turn from ${path}: ${cause}`),
-  })
+  tryAsync(`cannot read assistant reply turn from ${path}`, () =>
+    assistantReplyFromEvent(text, path),
+  )
 
 const replyWasProcessed = (sessionId: string, replyIdentity: string) =>
-  Effect.tryPromise({
-    try: () => hasProcessedReply(sessionId, replyIdentity),
-    catch: (cause) => new Error(`cannot read session state: ${cause}`),
-  })
+  tryAsync("cannot read session state", () => hasProcessedReply(sessionId, replyIdentity))
 
 const updateReplyFeedback = (
   sessionId: string,
   replyIdentity: string,
   feedback: string | undefined,
 ) =>
-  Effect.tryPromise({
-    try: () => setReplyFeedback(sessionId, replyIdentity, feedback),
-    catch: (cause) => new Error(`cannot update session state: ${cause}`),
-  })
+  tryAsync("cannot update session state", () =>
+    setReplyFeedback(sessionId, replyIdentity, feedback),
+  )
 
 const takePendingFeedback = (sessionId: string) =>
-  Effect.tryPromise({
-    try: () => consumePendingFeedback(sessionId),
-    catch: (cause) => new Error(`cannot read session state: ${cause}`),
-  })
+  tryAsync("cannot read session state", () => consumePendingFeedback(sessionId))
 
 const readSessionControl = (sessionId: string) =>
-  Effect.tryPromise({
-    try: () => getSessionControl(sessionId),
-    catch: (cause) => new Error(`cannot read session state: ${cause}`),
-  })
+  tryAsync("cannot read session state", () => getSessionControl(sessionId))
 
 const loadLintOptions = (cwd: string, tagger: Tagger) =>
   Effect.gen(function* () {
@@ -532,16 +457,6 @@ const loadLintOptions = (cwd: string, tagger: Tagger) =>
     return { ...config, dictionary, ruleData, tagger } satisfies LintOptions
   })
 
-function splitViolations(violations: readonly ReportViolation[]): {
-  readonly hard: ReportViolation[]
-  readonly soft: ReportViolation[]
-} {
-  return {
-    hard: violations.filter((violation) => violation.severity === "hard"),
-    soft: violations.filter((violation) => violation.severity === "soft"),
-  }
-}
-
 type EvaluationObservation = Omit<ObservationDraft, "sessionId" | "cwd">
 
 interface HookEvaluation {
@@ -603,15 +518,18 @@ function textDecision(
 
 function evaluateReply(event: StopEvent, tagger: Tagger): Effect.Effect<HookEvaluation, Error> {
   return Effect.gen(function* () {
-    const reply = yield* event.lastAssistantMessage === undefined
-      ? readAssistantReply(event.transcriptPath)
-      : readEventAssistantReply(event.lastAssistantMessage, event.transcriptPath)
+    if (event.lastAssistantMessage === undefined) {
+      return yield* Effect.fail(
+        new Error(`last_assistant_message was not provided for ${event.transcriptPath}`),
+      )
+    }
+    const reply = yield* readEventAssistantReply(event.lastAssistantMessage, event.transcriptPath)
     if (yield* replyWasProcessed(event.sessionId, reply.identity)) {
       return { output: {} as Record<string, never> }
     }
     const options = yield* loadLintOptions(event.cwd, tagger)
     const violations = lint("prose-file", reply.text, options).violations
-    const hard = violations.filter((violation) => violation.severity === "hard")
+    const { hard } = splitViolations(violations)
     const feedback =
       hard.length === 0
         ? undefined

package/src/cli/main.ts

@@ -2,6 +2,7 @@
 import { readFile } from "node:fs/promises"
 import { Effect, Result } from "effect"
 import packageManifest from "../../package.json" with { type: "json" }
+import { splitViolations } from "../adapter/feedback.ts"
 import { loadConfig } from "../config/load.ts"
 import { loadConfiguredDictionary } from "../dictionary/configured.ts"
 import { loadRuleData } from "../dictionary/load.ts"
@@ -102,7 +103,6 @@ interface FileViolation {
   readonly suggestions?: readonly string[]
   readonly line: number
   readonly column: number
-  readonly suggestion?: string
 }
 
 interface CliReport {
@@ -138,7 +138,7 @@ const toCliReport = (
     violations,
     summary: {
       total: violations.length,
-      hard: violations.filter((violation) => violation.severity === "hard").length,
+      hard: splitViolations(violations).hard.length,
     },
     skipped,
   }

package/src/cli/observation-log.ts

@@ -3,6 +3,7 @@ import { mkdir, open, readdir, readFile } from "node:fs/promises"
 import { join } from "node:path"
 import { createInterface } from "node:readline"
 import type { LintKind, ReportViolation } from "../engine/types.ts"
+import { isFileError } from "../fs-error.ts"
 import { applicationStateDirectory } from "./state-directory.ts"
 
 export type ObservationEvent = "write" | "edit" | "commit-message" | "reply"
@@ -56,12 +57,6 @@ const observationsDirectory = (): string => join(applicationStateDirectory(), "o
 
 const verdictsPath = (): string => join(applicationStateDirectory(), "verdicts.jsonl")
 
-function isFileError(cause: unknown, code: string): boolean {
-  return (
-    typeof cause === "object" && cause !== null && (cause as NodeJS.ErrnoException).code === code
-  )
-}
-
 async function appendJsonLine(path: string, value: unknown): Promise<void> {
   await mkdir(applicationStateDirectory(), { recursive: true, mode: 0o700 })
   const file = await open(path, "a", 0o600)

package/src/cli/session-state.ts

@@ -1,6 +1,8 @@
 import { createHash, randomUUID } from "node:crypto"
 import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises"
 import { join } from "node:path"
+import { setTimeout as wait } from "node:timers/promises"
+import { isFileError } from "../fs-error.ts"
 import { applicationStateDirectory } from "./state-directory.ts"
 
 export interface SessionControl {
@@ -19,9 +21,6 @@ const LOCK_STALE_MILLISECONDS = 10_000
 const LOCK_RETRY_MILLISECONDS = 5
 const LOCK_RETRIES = 200
 
-const isFileError = (cause: unknown, code: string): boolean =>
-  typeof cause === "object" && cause !== null && (cause as { code?: string }).code === code
-
 const sessionsDirectory = (): string => join(applicationStateDirectory(), "sessions")
 
 const sessionKey = (sessionId: string): string =>
@@ -41,27 +40,16 @@ function optionalString(state: Record<string, unknown>, name: string): string |
   return value as string | undefined
 }
 
-function decodeState(text: string, path: string): SessionState {
+function decodeState(text: string, path: string): SessionState | undefined {
   const value = JSON.parse(text) as unknown
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(`invalid session state in ${path}`)
   }
   const state = value as Record<string, unknown>
+  if (state.version !== 3) return undefined
   const pendingFeedback = optionalString(state, "pendingFeedback")
-  if (state.version === 1 && typeof pendingFeedback === "string") {
-    return { version: 3, ...DEFAULT_CONTROL, pendingFeedback }
-  }
   const lastProcessedReply = optionalString(state, "lastProcessedReply")
-  if (state.version === 2 && lastProcessedReply !== undefined && lastProcessedReply.length > 0) {
-    return {
-      version: 3,
-      ...DEFAULT_CONTROL,
-      lastProcessedReply,
-      ...(pendingFeedback === undefined ? {} : { pendingFeedback }),
-    }
-  }
   if (
-    state.version !== 3 ||
     typeof state.enabled !== "boolean" ||
     typeof state.strict !== "boolean" ||
     (state.strict && !state.enabled) ||
@@ -100,9 +88,6 @@ async function writeState(sessionId: string, state: SessionState): Promise<void>
   }
 }
 
-const wait = (milliseconds: number): Promise<void> =>
-  new Promise((resolve) => setTimeout(resolve, milliseconds))
-
 async function acquireLock(sessionId: string): Promise<() => Promise<void>> {
   const directory = sessionsDirectory()
   const path = lockPath(sessionId)

package/src/cli/try-async.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect"
+
+export const tryAsync = <T>(label: string, run: () => Promise<T>): Effect.Effect<T, Error> =>
+  Effect.tryPromise({
+    try: run,
+    catch: (cause) => new Error(`${label}: ${cause}`),
+  })

package/src/config/load.ts

@@ -2,6 +2,7 @@ import { readFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import { isAbsolute, join, resolve } from "node:path"
 import { Effect } from "effect"
+import { isFileError } from "../fs-error.ts"
 import { mergeConfigs } from "./merge.ts"
 import { ConfigError, decodeConfig, type SteConfig } from "./schema.ts"
 
@@ -32,9 +33,6 @@ export const legacyGlobalConfigPath = (cwd = process.cwd()): string =>
 export const legacyProjectConfigPath = (cwd: string): string =>
   join(cwd, ".pi", "simple-english.json")
 
-const isMissingFile = (cause: unknown): boolean =>
-  typeof cause === "object" && cause !== null && (cause as { code?: string }).code === "ENOENT"
-
 const readConfigFile = (
   path: string,
   optional: boolean,
@@ -45,7 +43,7 @@ const readConfigFile = (
   }).pipe(
     Effect.matchEffect({
       onFailure: (cause) =>
-        optional && isMissingFile(cause)
+        optional && isFileError(cause, "ENOENT")
           ? Effect.succeed(undefined)
           : Effect.fail(new ConfigError(`cannot read config file ${path}: ${cause}`)),
       onSuccess: (text) =>

package/src/engine/case-fold.ts

@@ -1,4 +1,3 @@
-import { caseFold } from "unicode-case-folding"
 import { TOKEN_RUN_PATTERN } from "./tokens.ts"
 
 export interface CaseFoldedToken {
@@ -7,7 +6,9 @@ export interface CaseFoldedToken {
   readonly offset: number
 }
 
-export const caseFoldKey = (text: string): string => caseFold(text)
+// ponytail: toLowerCase() does not fold "ss" from sharp s or merge sigma forms.
+// Add unicode-case-folding back if a dictionary needs that reach.
+export const caseFoldKey = (text: string): string => text.toLowerCase()
 
 export const tokenizeCaseFolded = (line: string): readonly CaseFoldedToken[] =>
   Array.from(line.matchAll(TOKEN_RUN_PATTERN), (match) => ({

package/src/engine/lint.ts

@@ -10,7 +10,7 @@ import { changedText } from "./diff.ts"
 import { newFindings, type ScopedViolation, type ViolationScope } from "./diff-match.ts"
 import { extractHtmlProse } from "./html.ts"
 import { blankIdentifiers } from "./identifiers.ts"
-import { blankMarkdownForLint } from "./markdown.ts"
+import { type BlockStructure, blankMarkdownForLint } from "./markdown.ts"
 import { type Paragraph, segmentParagraphs } from "./paragraphs.ts"
 import { contraction } from "./rules/contraction.ts"
 import { type CompiledDictionary, compileDictionary, dictionaryRule } from "./rules/dictionary.ts"
@@ -65,6 +65,7 @@ interface PreparedProse {
   readonly structuralBlanks: readonly boolean[]
   readonly wordingStructuralBlanks: readonly boolean[]
   readonly sentenceBoundaryLines: readonly boolean[]
+  readonly blocks: BlockStructure
 }
 
 interface SentenceScopeIndex {
@@ -192,6 +193,7 @@ const prepareProse = (
     structuralBlanks: markdown.structuralBlanks,
     wordingStructuralBlanks: markdown.wordingStructuralBlanks,
     sentenceBoundaryLines: markdown.sentenceBoundaryLines,
+    blocks: markdown.blocks,
   }
 }
 
@@ -312,6 +314,12 @@ const lintProse = (
     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),
+      ),
+    },
   )
   const offsets = lineOffsets(prepared.structuralLines)
   const sentenceIndex = indexSentenceScopes(sentences, prepared.lines.length, sourceOffset)
@@ -399,8 +407,8 @@ const lintProse = (
           dictionaryRule(
             prepared.wordingStructuralLines,
             options.dictionary,
+            prepared.blocks,
             options.tagger,
-            contentStarts,
             prepared.wordingDictionaryLines,
           ),
           dictionarySentenceIndex,

package/src/engine/markdown.ts

@@ -16,12 +16,14 @@ interface MarkdownAnalysis {
   readonly structuralBlanks: boolean[]
   readonly wordingStructuralBlanks: boolean[]
   readonly sentenceBoundaryLines: boolean[]
+  readonly blocks: BlockStructure
 }
 
-export interface MarkdownCodeResult {
-  readonly lines: string[]
-  readonly structuralLines: string[]
-  readonly structuralBlanks: boolean[]
+// 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 interface BlockStructure {
+  readonly ids: readonly number[]
+  readonly contentStarts: readonly number[]
 }
 
 interface AnalysisState {
@@ -37,6 +39,8 @@ interface AnalysisState {
   readonly blockQuoteLines: Uint8Array | undefined
   readonly structuralBlanks: boolean[]
   readonly sentenceBoundaryLines: boolean[]
+  readonly blockIds: number[]
+  readonly blockContentStarts: number[]
 }
 
 interface SourceRange {
@@ -153,6 +157,22 @@ 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",
+  "codeIndented",
+  "definition",
+  "htmlFlow",
+  "htmlRawFlow",
+  "paragraph",
+  "setextHeadingLine",
+  "setextHeadingText",
+  "table",
+  "thematicBreak",
+  "yaml",
+])
 const DICTIONARY_TOKENS = new Set([
   "atxHeadingSequence",
   "autolink",
@@ -221,6 +241,15 @@ const createAnalysisState = (
     blockQuoteLines: exemptBlockQuotes ? new Uint8Array(parseLines.length) : undefined,
     structuralBlanks: parseLines.map((line) => line.trim() === ""),
     sentenceBoundaryLines: parseLines.map(() => false),
+    blockIds: parseLines.map(() => -1),
+    blockContentStarts: parseLines.map(() => 0),
+  }
+}
+
+const markLeafBlock = (state: AnalysisState, token: MarkdownToken, blockId: number): void => {
+  const lastLine = Math.min(token.end.line - 1, state.parseLines.length - 1)
+  for (let line = token.start.line - 1; line <= lastLine; line++) {
+    state.blockIds[line] = blockId
   }
 }
 
@@ -432,6 +461,7 @@ const analyzeEvents = (state: AnalysisState, includeDictionary: boolean): void =
   const definitionEnds = includeDictionary ? definitionMaskEnds(events) : new Map<number, number>()
   const htmlFlows: SourceRange[] = []
   let blockQuoteDepth = 0
+  let nextBlockId = 0
 
   for (const [phase, token] of events) {
     if (token.type === "blockQuote" && state.blockQuoteMask !== undefined) {
@@ -447,11 +477,19 @@ const analyzeEvents = (state: AnalysisState, includeDictionary: boolean): void =
     if (SENTENCE_BOUNDARY_TOKENS.has(token.type)) {
       state.sentenceBoundaryLines[token.start.line - 1] = true
     }
+    if (LEAF_BLOCK_TOKENS.has(token.type)) {
+      markLeafBlock(state, token, nextBlockId++)
+    }
     if (NON_PROSE_BLOCK_TOKENS.has(token.type)) {
       markNonProseBlock(state, token)
       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,
+      )
       markRange(state.proseMask, token.start.offset, token.end.offset)
       markRange(state.containerMask, token.start.offset, token.end.offset)
       if (includeDictionary) {
@@ -523,6 +561,7 @@ const analyzeMarkdown = (
       structuralBlanks: [],
       wordingStructuralBlanks: [],
       sentenceBoundaryLines: [],
+      blocks: { ids: [], contentStarts: [] },
     }
   }
 
@@ -596,6 +635,12 @@ const analyzeMarkdown = (
             (blank, lineIndex) => blank || state.blockQuoteLines?.[lineIndex] === 1,
           ),
     sentenceBoundaryLines: state.sentenceBoundaryLines,
+    blocks: {
+      ids: state.blockIds,
+      contentStarts: state.blockContentStarts.map(
+        (contentStart, index) => (starts[index] ?? 0) + contentStart,
+      ),
+    },
   }
 }
 
@@ -607,78 +652,3 @@ export function blankMarkdownForLint(
 ): MarkdownAnalysis {
   return analyzeMarkdown(inputLines, contentStarts, includeDictionary, exemptBlockQuotes)
 }
-
-export function blankMarkdownCodeWithStructure(
-  inputLines: readonly string[],
-  contentStarts: readonly number[] = inputLines.map(() => 0),
-): MarkdownCodeResult {
-  const analysis = analyzeMarkdown(inputLines, contentStarts, false)
-  return {
-    lines: analysis.lines,
-    structuralLines: analysis.structuralLines,
-    structuralBlanks: analysis.structuralBlanks,
-  }
-}
-
-export function blankMarkdownCode(
-  inputLines: readonly string[],
-  contentStarts: readonly number[] = inputLines.map(() => 0),
-): string[] {
-  return analyzeMarkdown(inputLines, contentStarts, false).lines
-}
-
-export function maskMarkdownCode(text: string): string {
-  return blankMarkdownCode(text.split("\n")).join("\n")
-}
-
-export function blankMarkdownDestinations(
-  lines: readonly string[],
-  contentStarts: readonly number[] = lines.map(() => 0),
-): string[] {
-  return analyzeMarkdown(lines, contentStarts).dictionaryLines
-}
-
-export function blankInlineCode(lines: readonly string[]): string[] {
-  const source = lines.join("\n")
-  const mask = new Uint8Array(source.length)
-  const parser = source.includes(")") ? commonMarkParser : codeOnlyInlineParser
-  const pending = [...(parser.parseInline(source, 0) as readonly InlineElement[])]
-
-  while (pending.length > 0) {
-    const element = pending.pop()
-    if (element === undefined) continue
-    if (element.children !== undefined) pending.push(...element.children)
-    if (inlineElementName(element) === "InlineCode") {
-      markRange(mask, element.from, element.to)
-    }
-  }
-
-  let offset = 0
-  return lines.map((line) => {
-    const characters = line.split("")
-    for (let index = 0; index < line.length; index++) {
-      if (mask[offset + index] !== 0) characters[index] = " "
-    }
-    offset += line.length + 1
-    return characters.join("")
-  })
-}
-
-export function proseVisibility(text: string): Uint8Array {
-  const visibility = new Uint8Array(text.length)
-  const sourceLines = text.split("\n")
-  const proseLines = blankMarkdownCode(sourceLines)
-  let offset = 0
-
-  for (let index = 0; index < sourceLines.length; index++) {
-    const line = sourceLines[index] ?? ""
-    if (line === proseLines[index]) visibility.fill(1, offset, offset + line.length)
-    offset += line.length
-    if (offset < text.length) {
-      visibility[offset] = 1
-      offset++
-    }
-  }
-
-  return visibility
-}

package/src/engine/paragraphs.ts

@@ -1,3 +1,5 @@
+import type { BlockStructure } from "./markdown.ts"
+
 export interface Paragraph {
   readonly lines: readonly string[]
   readonly boundaryLines: readonly string[]
@@ -5,140 +7,50 @@ export interface Paragraph {
   readonly column: number
 }
 
-const LIST_MARKER = /^(?:[-*+]|\d+[.)])\s+/
-
-type LineKind = "blank" | "block-boundary" | "blockquote" | "list-item" | "prose"
-type ParagraphKind = "blockquote" | "blockquote-list-item" | "list-item" | "prose"
-
-const ATX_HEADING = /^ {0,3}#{1,6}(?:[ \t]+|$)/
-const BLOCKQUOTE = /^ {0,3}>[ \t]?/
-
-function listItemContent(line: string): string | undefined {
-  const trimmed = line.trimStart()
-  const marker = LIST_MARKER.exec(trimmed)
-  return marker ? trimmed.slice(marker[0].length) : undefined
-}
-
-function blockquoteContent(line: string): string | undefined {
-  const marker = BLOCKQUOTE.exec(line)
-  return marker ? line.slice(marker[0].length) : undefined
-}
-
-function trimSharedIndent(line: string, boundaryLine: string): readonly [string, string] {
-  const indent = boundaryLine.length - boundaryLine.trimStart().length
-  return [line.slice(indent), boundaryLine.slice(indent)]
-}
-
-export function isParagraphBoundaryLine(line: string): boolean {
-  return line.trim().startsWith("|") || ATX_HEADING.test(line)
-}
-
-function classify(line: string): LineKind {
-  const trimmed = line.trim()
-  if (trimmed === "") return "blank"
-  if (isParagraphBoundaryLine(line)) return "block-boundary"
-  if (blockquoteContent(line) !== undefined) return "blockquote"
-  if (listItemContent(line) !== undefined) return "list-item"
-  return "prose"
+interface OpenParagraph {
+  readonly blockId: number
+  readonly line: number
+  readonly column: number
+  readonly lines: string[]
+  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(
   lines: readonly string[],
-  columns: readonly number[] = lines.map(() => 1),
-  boundaryLines: readonly string[] = lines,
+  columns: readonly number[],
+  boundaryLines: readonly string[],
+  blocks: BlockStructure,
 ): Paragraph[] {
   const paragraphs: Paragraph[] = []
-  let open: {
-    line: number
-    column: number
-    lines: string[]
-    boundaryLines: string[]
-    kind: ParagraphKind
-  } | null = null
+  let open: OpenParagraph | undefined
 
   const close = () => {
-    if (open) {
-      paragraphs.push({
-        lines: open.lines,
-        boundaryLines: open.boundaryLines,
-        line: open.line,
-        column: open.column,
-      })
-      open = null
-    }
+    if (open !== undefined) paragraphs.push(open)
+    open = undefined
   }
 
   lines.forEach((raw, index) => {
-    const boundaryRaw = boundaryLines[index] ?? raw
-    switch (classify(raw)) {
-      case "blank":
-      case "block-boundary":
-        close()
-        break
-      case "blockquote": {
-        const content = blockquoteContent(raw) ?? ""
-        const boundaryContent = blockquoteContent(boundaryRaw) ?? ""
-        const contentKind = classify(content)
-        if (contentKind === "blank" || contentKind === "block-boundary") {
-          close()
-          break
-        }
-        if (contentKind === "list-item") {
-          close()
-          open = {
-            line: index + 1,
-            column: columns[index] ?? 1,
-            lines: [listItemContent(content) ?? ""],
-            boundaryLines: [listItemContent(boundaryContent) ?? ""],
-            kind: "blockquote-list-item",
-          }
-          break
-        }
-        if (open?.kind !== "blockquote" && open?.kind !== "blockquote-list-item") close()
-        if (!open) {
-          open = {
-            line: index + 1,
-            column: columns[index] ?? 1,
-            lines: [],
-            boundaryLines: [],
-            kind: "blockquote",
-          }
-        }
-        const [paragraphContent, paragraphBoundaryContent] =
-          open.kind === "blockquote-list-item"
-            ? trimSharedIndent(content, boundaryContent)
-            : [content, boundaryContent]
-        open.lines.push(paragraphContent)
-        open.boundaryLines.push(paragraphBoundaryContent)
-        break
-      }
-      case "list-item":
-        close()
-        open = {
-          line: index + 1,
-          column: columns[index] ?? 1,
-          lines: [listItemContent(raw) ?? ""],
-          boundaryLines: [listItemContent(boundaryRaw) ?? ""],
-          kind: "list-item",
-        }
-        break
-      case "prose": {
-        if (!open) {
-          open = {
-            line: index + 1,
-            column: columns[index] ?? 1,
-            lines: [],
-            boundaryLines: [],
-            kind: "prose",
-          }
-        }
-        const [content, boundaryContent] =
-          open.kind === "list-item" ? trimSharedIndent(raw, boundaryRaw) : [raw, boundaryRaw]
-        open.lines.push(content)
-        open.boundaryLines.push(boundaryContent)
-        break
+    const blockId = blocks.ids[index] ?? -1
+    if (blockId < 0) {
+      close()
+      return
+    }
+    if (open !== undefined && open.blockId !== blockId) close()
+    if (open === undefined) {
+      open = {
+        blockId,
+        line: index + 1,
+        column: columns[index] ?? 1,
+        lines: [],
+        boundaryLines: [],
       }
     }
+
+    const contentStart = blocks.contentStarts[index] ?? 0
+    open.lines.push(raw.slice(contentStart))
+    open.boundaryLines.push((boundaryLines[index] ?? raw).slice(contentStart))
   })
   close()
 

package/src/engine/rules/dictionary.ts

@@ -1,5 +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 { TaggedToken, Tagger } from "../tagger.ts"
 import type { Violation } from "../types.ts"
 
@@ -19,22 +20,6 @@ export type CompiledDictionary =
   | { readonly mode: "approved-words"; readonly approvedWords: ReadonlySet<string> }
   | { readonly mode: "not-approved"; readonly forms: readonly Form[] }
 
-interface MarkdownContext {
-  readonly contentStart: number
-  readonly quoteDepth: number
-  readonly paragraphId?: number
-}
-
-interface ActiveParagraph {
-  readonly id: number
-  readonly quoteDepth: number
-}
-
-const ATX_HEADING = /^ {0,3}#{1,6}(?:[\t ]+|$)/
-const LIST_MARKER = /^ {0,3}(?:[-+*]|\d{1,9}[.)])(?:[\t ]+|$)/
-const SETEXT_UNDERLINE = /^ {0,3}(?:=+|-+)[\t ]*\r?$/
-const THEMATIC_BREAK = /^ {0,3}(?:(?:\*[\t ]*){3,}|(?:_[\t ]*){3,}|(?:-[\t ]*){3,})\r?$/
-
 const tokenize = (lines: readonly string[]): readonly WordToken[] => {
   const tokenPattern = new RegExp(DICTIONARY_TOKEN_SOURCE, "gu")
   return lines.flatMap((line, lineIndex) =>
@@ -62,89 +47,10 @@ export const compileDictionary = (dictionary: DictionaryData): CompiledDictionar
       }
     : { mode: "not-approved", forms: compileForms(dictionary) }
 
-const markdownContext = (line: string, initialContentStart = 0): MarkdownContext => {
-  let contentStart = Math.min(initialContentStart, line.length)
-  let quoteDepth = 0
-
-  while (contentStart < line.length) {
-    let marker = contentStart
-    let spaces = 0
-    while (spaces < 4 && line[marker] === " ") {
-      marker++
-      spaces++
-    }
-    if (spaces > 3 || line[marker] !== ">") {
-      break
-    }
-    contentStart = marker + 1
-    if (line[contentStart] === " " || line[contentStart] === "\t") {
-      contentStart++
-    }
-    quoteDepth++
-  }
-
-  return { contentStart, quoteDepth }
-}
-
-const blockContent = (line: string, context: MarkdownContext): string =>
-  line.slice(context.contentStart)
-
-const isLeafBlock = (content: string): boolean => {
-  const listMarker = content.match(LIST_MARKER)
-  const nestedContent = listMarker === null ? content : content.slice(listMarker[0].length)
-  return ATX_HEADING.test(nestedContent)
-}
-
-const startsNewBlock = (content: string): boolean =>
-  ATX_HEADING.test(content) ||
-  LIST_MARKER.test(content) ||
-  SETEXT_UNDERLINE.test(content) ||
-  THEMATIC_BREAK.test(content)
-
-const isParagraphBlock = (content: string): boolean =>
-  !isLeafBlock(content) && !SETEXT_UNDERLINE.test(content) && !THEMATIC_BREAK.test(content)
-
-const isIndentedCode = (content: string): boolean => /^(?: {4}|\t)/.test(content)
-
-const markdownContexts = (
-  lines: readonly string[],
-  contentStarts: readonly number[],
-): readonly MarkdownContext[] => {
-  let activeParagraph: ActiveParagraph | undefined
-  let nextParagraphId = 0
-
-  return lines.map((line, lineIndex) => {
-    const context = markdownContext(line, contentStarts[lineIndex] ?? 0)
-    const content = blockContent(line, context)
-    if (/^[\t ]*\r?$/.test(content)) {
-      activeParagraph = undefined
-      return context
-    }
-
-    if (
-      activeParagraph !== undefined &&
-      context.quoteDepth <= activeParagraph.quoteDepth &&
-      !startsNewBlock(content)
-    ) {
-      return { ...context, paragraphId: activeParagraph.id }
-    }
-
-    if (isIndentedCode(content)) {
-      activeParagraph = undefined
-      return context
-    }
-
-    const paragraphId = nextParagraphId++
-    activeParagraph = isParagraphBlock(content)
-      ? { id: paragraphId, quoteDepth: context.quoteDepth }
-      : undefined
-    return { ...context, paragraphId }
-  })
-}
-
+// Two words join across a line break only inside one Markdown leaf block.
 const isSoftLineBreak = (
   lines: readonly string[],
-  contexts: readonly MarkdownContext[],
+  blocks: BlockStructure,
   previous: WordToken,
   token: WordToken,
 ): boolean => {
@@ -157,26 +63,20 @@ const isSoftLineBreak = (
     return false
   }
 
-  const previousContext = contexts[previous.lineIndex]
-  const nextContext = contexts[token.lineIndex]
-  if (
-    previousContext === undefined ||
-    nextContext === undefined ||
-    previousContext.paragraphId === undefined ||
-    previousContext.paragraphId !== nextContext.paragraphId
-  ) {
+  const previousBlock = blocks.ids[previous.lineIndex] ?? -1
+  if (previousBlock < 0 || previousBlock !== blocks.ids[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(nextContext.contentStart, token.offset)
+  const leading = nextLine.slice(blocks.contentStarts[token.lineIndex] ?? 0, token.offset)
   return (trailing === "" || trailing === " ") && /^[\t ]*$/.test(leading)
 }
 
 const hasWords = (
   lines: readonly string[],
-  contexts: readonly MarkdownContext[],
+  blocks: BlockStructure,
   tokens: readonly WordToken[],
   start: number,
   words: readonly string[],
@@ -200,7 +100,7 @@ const hasWords = (
         /^\s+$/.test(line.slice(previous.offset + previous.text.length, token.offset))
       )
     }
-    return isSoftLineBreak(lines, contexts, previous, token)
+    return isSoftLineBreak(lines, blocks, previous, token)
   })
 
 const hasPartOfSpeech = (
@@ -246,8 +146,8 @@ const approvedWordRule = (
 export function dictionaryRule(
   lines: readonly string[],
   dictionary: CompiledDictionary,
+  blocks: BlockStructure,
   tagger?: Tagger,
-  contentStarts: readonly number[] = lines.map(() => 0),
   proseLines: readonly string[] = lines,
 ): Violation[] {
   if (dictionary.mode === "approved-words") {
@@ -255,7 +155,6 @@ export function dictionaryRule(
   }
   const forms = dictionary.forms
   const violations: Violation[] = []
-  const contexts = markdownContexts(lines, contentStarts)
   const tokens = tokenize(lines)
   const taggedTokensByLine = new Map<number, readonly TaggedToken[]>()
 
@@ -264,7 +163,7 @@ export function dictionaryRule(
     if (first === undefined) {
       continue
     }
-    const candidates = forms.filter((form) => hasWords(lines, contexts, tokens, index, form.words))
+    const candidates = forms.filter((form) => hasWords(lines, blocks, tokens, index, form.words))
     const match = candidates.find((form) => {
       if (form.entry.partsOfSpeech === undefined) {
         return true

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

@@ -46,7 +46,7 @@ export function phrasalVerb(lines: readonly string[], dictionary: Dictionary): V
       message: `Do not use a phrasal verb. Use "${suggestion}", not "${match.found.toLowerCase()}".`,
       line: match.line,
       column: match.column,
-      suggestion,
+      suggestions: [suggestion],
     })),
   )
 }

package/src/engine/sentences.ts

@@ -1,5 +1,3 @@
-import { isParagraphBoundaryLine } from "./paragraphs.ts"
-
 export interface Sentence {
   readonly text: string
   readonly line: number
@@ -156,34 +154,6 @@ function underscoreEmphasisClosers(
   return closers
 }
 
-function atxHeadingPrefixes(text: string): Uint8Array {
-  const prefixes = new Uint8Array(text.length)
-  let lineStart = 0
-
-  for (let lineEnd = 0; lineEnd <= text.length; lineEnd += 1) {
-    if (lineEnd < text.length && text[lineEnd] !== "\n") continue
-
-    let markerStart = lineStart
-    while (markerStart < lineEnd && markerStart - lineStart < 3 && text[markerStart] === " ") {
-      markerStart += 1
-    }
-    let markerEnd = markerStart
-    while (markerEnd < lineEnd && markerEnd - markerStart < 6 && text[markerEnd] === "#") {
-      markerEnd += 1
-    }
-    if (
-      markerEnd > markerStart &&
-      text[markerEnd] !== "#" &&
-      (markerEnd === lineEnd || /[ \t]/u.test(text[markerEnd] ?? ""))
-    ) {
-      prefixes.fill(1, markerStart, markerEnd)
-    }
-    lineStart = lineEnd + 1
-  }
-
-  return prefixes
-}
-
 function contentLookahead(
   text: string,
   brackets: Int32Array,
@@ -191,11 +161,10 @@ function contentLookahead(
 ): Int32Array {
   const attached = new Int32Array(text.length + 1).fill(-1)
   const detached = new Int32Array(text.length + 1).fill(-1)
-  const headingPrefixes = atxHeadingPrefixes(text)
 
   for (let index = text.length - 1; index >= 0; index -= 1) {
     const character = text[index] ?? ""
-    if (/\s/u.test(character) || headingPrefixes[index] === 1) {
+    if (/\s/u.test(character)) {
       attached[index] = sentinelAt(detached, index + 1)
       detached[index] = sentinelAt(detached, index + 1)
       continue
@@ -502,11 +471,8 @@ export function segmentSentences(
   const boundaryAnalysis = analyzeBoundaryText(boundaryText)
   const boundaryOffsets: number[] = []
   const paragraphEnds: number[] = []
-  const lookaheadBreaks = effectiveBoundaryLines.map(
-    (line, index) =>
-      (structuralBlanks[index] ?? true) ||
-      (sentenceBoundaryLines[index] ?? false) ||
-      isParagraphBoundaryLine(line),
+  const lookaheadBreaks = lines.map(
+    (_line, index) => (structuralBlanks[index] ?? true) || (sentenceBoundaryLines[index] ?? false),
   )
   let boundaryOffset = 0
   for (const line of effectiveBoundaryLines) {

package/src/engine/types.ts

@@ -16,7 +16,6 @@ export interface Violation {
   readonly suggestions?: readonly string[]
   readonly line: number
   readonly column: number
-  readonly suggestion?: string
 }
 
 export interface ReportViolation extends Violation {

package/src/extension/index.ts

@@ -16,7 +16,7 @@ import type { AutocompleteItem } from "@earendil-works/pi-tui"
 import { Effect } from "effect"
 import { Type } from "typebox"
 import { blankCommitMetadata, findCommitInvocations } from "../adapter/commit-message.ts"
-import { formatViolations, violationDetails } from "../adapter/feedback.ts"
+import { formatViolations, splitViolations, violationDetails } from "../adapter/feedback.ts"
 import { formatStatusSummary, ruleSummary } from "../adapter/rule-summary.ts"
 import { loadConfig } from "../config/load.ts"
 import type { SteConfig } from "../config/schema.ts"
@@ -236,6 +236,24 @@ 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
@@ -292,7 +310,7 @@ function showReplyReport(
   report: LintReport,
   queueFeedback: boolean,
 ): void {
-  const hard = report.violations.filter((violation) => violation.severity === "hard")
+  const { hard } = splitViolations(report.violations)
   const softCount = report.summary.total - report.summary.hard
   state.pendingReplyFeedback =
     queueFeedback && hard.length > 0 ? formatReplyFeedback(hard) : undefined
@@ -364,8 +382,7 @@ function lintProposedText(
     sourceDialect: classification.sourceDialect,
     previousText,
   })
-  const hard = report.violations.filter((violation) => violation.severity === "hard")
-  const soft = report.violations.filter((violation) => violation.severity === "soft")
+  const { hard, soft } = splitViolations(report.violations)
   notifyWarnings(ctx, path, soft)
   if (hard.length === 0) {
     if (soft.length > 0) {
@@ -457,7 +474,7 @@ function lintStrictReply(
   }
   const report = lintReply(state, text)
   showReplyReport(state, ctx, report, false)
-  const hard = report.violations.filter((violation) => violation.severity === "hard")
+  const { hard } = splitViolations(report.violations)
   if (hard.length === 0) return undefined
   return {
     block: true,

package/src/fs-error.ts

@@ -0,0 +1,5 @@
+export function isFileError(cause: unknown, code: string): boolean {
+  return (
+    typeof cause === "object" && cause !== null && (cause as NodeJS.ErrnoException).code === code
+  )
+}