agent-simple-english 0.7.0 → 0.8.0

package/.claude-plugin/marketplace.json

@@ -10,8 +10,8 @@
   "plugins": [
     {
       "name": "simple-english",
-      "description": "Apply technical and house-style writing rules to writes, edits, and git commit messages.",
-      "version": "0.7.0",
+      "description": "Apply technical and house-style writing rules to writes, edits, git commit messages, and replies. Needs Claude Code 2.1.296 or later.",
+      "version": "0.8.0",
       "author": {
         "name": "JIA YI"
       },

package/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "simple-english",
-  "version": "0.7.0",
-  "description": "Apply technical and house-style writing rules to writes, edits, and git commit messages.",
+  "version": "0.8.0",
+  "description": "Apply technical and house-style writing rules to writes, edits, git commit messages, and replies. Needs Claude Code 2.1.296 or later.",
   "repository": "https://github.com/jyooi/agent-simple-english",
   "license": "MIT",
   "keywords": ["simplified-technical-english", "lint", "hooks"],

package/README.md

@@ -38,6 +38,7 @@ A config, dictionary, or rule-data load error makes enabled write, edit, and com
 ## Install the Claude Code Adapter
 
 Install [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and [Bun](https://bun.sh) first.
+The plugin needs Claude Code 2.1.296 or later.
 Then use the standard local plugin flow:
 
 ```sh
@@ -87,22 +88,44 @@ Then use the full name.
 | `/ase strict off` | Disable the strict reply gate and use reply feedback. |
 | `/ase explain` | Write the last reply again in Simplified Technical English. |
 
-Claude Code 2.1.292 or later shows argument suggestions while you type.
+Claude Code shows argument suggestions while you type.
 Type `/ase`, press Tab to select the command, then type the first letters of an argument.
 The list shows each argument that starts with those letters, and Tab completes the first one.
 After `strict`, the list suggests `off`.
 
-An earlier Claude Code version shows only the fixed argument hint.
-Claude Code 2.1.287 to 2.1.291 also show one load error for the suggestion module at session start.
-The writing-rule hooks continue to operate on those versions.
+### Strict reply hold
 
-Strict mode blocks a `Stop` event when the reply has a hard violation.
-Claude Code then uses the violation details to write the reply again.
-The `stop_hook_active` check stops a second block in the same rewrite loop.
+Strict mode holds each reply of the main conversation until the reply check completes.
+Claude Code shows no reply text during the hold.
+A reply with no hard violation then shows unchanged.
+For a reply with a hard violation, Claude Code shows one notice line in place of the text.
+The model then gets the held text and the violation details, and it writes the reply again.
+The Adapter holds and checks that rewrite the same way.
 
-Claude Code shows streamed reply text before the `Stop` hook runs.
-Thus, strict mode can reject the completed reply, but it cannot redact text that Claude Code already showed.
-The pi Adapter does not have this gap because its `say` tool hides strict reply text before approval.
+The model gets a maximum of two rewrites in one turn.
+The sequence is: the Adapter blocks the first reply, the Adapter blocks the first rewrite, and Claude Code shows the second rewrite.
+The second rewrite shows as the model wrote it, also when it has a hard violation.
+
+A step that has text and a tool call uses the same hold, and the tool runs.
+For such a step with a hard violation, Claude Code shows the notice line, and the Adapter keeps the text.
+The Adapter blocks only when the last reply of the turn has a hard violation.
+The model then also gets the kept text and the violation details of the earlier steps.
+If the last reply has no hard violation, the Adapter does not block, and the reply shows one time.
+The kept text of a step with a tool call does not use one of the two rewrites.
+The hold does not apply to subagent replies.
+If the reply check fails, the Adapter shows the reply and adds one warning line.
+After an interrupt during the hold, Claude Code shows no text for that reply.
+
+The hold has these limits:
+
+- Strict mode shows no streamed text, because a held reply appears only when it is complete.
+- The transcript file contains the held text in the feedback message for the model.
+  The `stream-json` output of `claude -p` also contains that message.
+- A `Stop` hook from another source does not run for a blocked reply.
+  It runs for the reply that the user sees.
+
+The `Stop` command hook stays as a second layer.
+It blocks one `Stop` event when a reply with a hard violation showed after a failed reply check.
 
 ### Reply feedback loop
 
@@ -185,6 +208,17 @@ The hook also allows the event when configuration, dictionary, rule-data, tagger
 It adds warning text for these operational failures.
 Observation-write failures are silent and do not change the hook output or decision.
 
+### Claude Code reply check
+
+The `reply-check` subcommand reads one JSON object from standard input.
+The object has the `session_id`, `cwd`, and `text` fields.
+The subcommand checks the text as a reply with the config of that working directory.
+
+It writes one JSON object, which has a `feedback` field only when the text has a hard violation.
+It also records one denied reply Observation for that text.
+An input or load error causes exit code 2.
+The hooks module of the plugin runs this subcommand for the strict reply hold.
+
 ### Review hook observations
 
 Enabled Hook mode logs every write, edit, static commit-message, and reply lint decision to the local XDG state directory.
@@ -468,6 +502,8 @@ See [Configuration](#configuration) for list selection, precedence, and load err
 Default: hard.
 Reports a prose paragraph that has more than six sentences.
 Markdown block boundaries and list items start separate paragraphs.
+An ordered list item starts a list with any start number, also directly below a paragraph line.
+CommonMark keeps such a line in the paragraph when the number is not 1.
 Sentence counts use the [`sentence-length`](#sentence-length) segmentation rules.
 
 #### `phrasal-verb`
@@ -494,6 +530,8 @@ It keeps an abbreviation in the current sentence when lowercase prose follows it
 It preserves a sentence boundary before capitalized prose, except after a single capital letter or before a short `Fig.` or `No.` designator such as `Fig. A` or `No. 7`.
 Markdown block boundaries stop abbreviation lookahead.
 
+The start of a list item ends the sentence before it.
+
 #### `verb-progressive`
 
 Default: hard.

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "Inject active writing rules, gate changes, and return reply feedback on the next prompt.",
+  "description": "Inject active writing rules, gate changes, hold strict replies, and return reply feedback on the next prompt.",
 
   "modules": ["./register.ts"],
 

package/hooks/register.ts

@@ -1,3 +1,5 @@
+import { blockHeldReply, holdReply, restoreReply } from "./reply-hold.ts"
+
 interface Suggestion {
   readonly text: string
   readonly description: string
@@ -41,11 +43,19 @@ export function aseSuggestions(text: string, token: string, start: number): read
   return words.filter((word) => word.text.startsWith(typed) && word.text !== typed)
 }
 
-export function register(on: (event: "prompt.autocomplete", hook: AutocompleteHook) => void): void {
+interface On {
+  (event: "prompt.autocomplete", hook: AutocompleteHook): unknown
+  (event: "turn.step", hook: typeof holdReply): { catch(handler: typeof restoreReply): void }
+  (event: "classic.Stop", hook: typeof blockHeldReply): unknown
+}
+
+export function register(on: On): void {
   on("prompt.autocomplete", async (_engine, input, next) => ({
     suggestions: [
       ...aseSuggestions(input.text, input.token, input.start),
       ...(await next(input)).suggestions,
     ],
   }))
+  on("turn.step", holdReply).catch(restoreReply)
+  on("classic.Stop", blockHeldReply)
 }

package/hooks/reply-hold.ts

@@ -0,0 +1,179 @@
+export const REPLY_HOLD_NOTICE = "The writing rules held this reply. A corrected reply follows."
+
+const BLOCK_LIMIT = 2
+
+type Piece = Readonly<Record<string, unknown>> & { readonly kind: string }
+
+interface StepResult {
+  readonly answer: string
+  readonly toolUses: readonly { readonly name: string; readonly input: unknown }[]
+  readonly stopReason: string | null
+  readonly usage: unknown
+}
+
+interface StepEvent {
+  readonly turnId: string
+  readonly index: number
+  readonly agentId?: string
+}
+
+interface StepNext {
+  (e: StepEvent): AsyncGenerator<Piece, StepResult>
+  readonly signal: { readonly aborted: boolean }
+}
+
+interface HoldApi {
+  readonly env: { get(name: string): Promise<string | undefined> }
+  readonly fs: { read(path: string): Promise<string> }
+  readonly session: { id(): Promise<string>; cwd(): Promise<string> }
+  readonly process: {
+    run(
+      argv: readonly string[],
+      init?: { cwd?: string; stdin?: string },
+    ): Promise<{ exitCode: number; stdout: string; stderr: string }>
+  }
+  readonly plugin: { readonly root: string }
+  readonly ui: { log(text: string): void }
+}
+
+interface HeldReply {
+  readonly reply: string
+  readonly feedback: string
+}
+
+type StopResult = Readonly<Record<string, unknown>>
+
+let turn = { id: "", blocks: 0, held: [] as HeldReply[], lastStepHeld: false }
+
+export async function sessionStatePath(
+  sessionId: string,
+  stateHome: string | undefined,
+  home: string | undefined,
+): Promise<string> {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(sessionId))
+  const key = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0"))
+  const root = stateHome?.startsWith("/") ? stateHome : `${home}/.local/state`
+  return `${root}/simple-english/sessions/${key.join("")}.json`
+}
+
+async function strictSession($: HoldApi): Promise<boolean> {
+  try {
+    const path = await sessionStatePath(
+      await $.session.id(),
+      await $.env.get("XDG_STATE_HOME"),
+      await $.env.get("HOME"),
+    )
+    const state = JSON.parse(await $.fs.read(path)) as { enabled?: unknown; strict?: unknown }
+    return state.enabled === true && state.strict === true
+  } catch {
+    return false
+  }
+}
+
+async function replyFeedback($: HoldApi, text: string): Promise<string | undefined> {
+  const check = await $.process.run(["bun", "src/cli/main.ts", "reply-check"], {
+    cwd: $.plugin.root,
+    stdin: JSON.stringify({ session_id: await $.session.id(), cwd: await $.session.cwd(), text }),
+  })
+  if (check.exitCode !== 0) throw new Error(check.stderr.trim() || `exit code ${check.exitCode}`)
+  const feedback = (JSON.parse(check.stdout) as { feedback?: unknown }).feedback
+  return typeof feedback === "string" ? feedback : undefined
+}
+
+async function readAll(
+  stream: AsyncGenerator<Piece, StepResult>,
+): Promise<{ pieces: Piece[]; result: StepResult }> {
+  const pieces: Piece[] = []
+  let item = await stream.next()
+  while (item.done !== true) {
+    pieces.push(item.value)
+    item = await stream.next()
+  }
+  return { pieces, result: item.value }
+}
+
+function* noticePieces(pieces: readonly Piece[]): Generator<Piece> {
+  let replaced = false
+  for (const piece of pieces) {
+    if (piece.kind !== "text") {
+      yield piece
+    } else if (!replaced) {
+      replaced = true
+      yield { ...piece, text: REPLY_HOLD_NOTICE }
+    }
+  }
+}
+
+const blockReason = (held: readonly HeldReply[]): string =>
+  [
+    "The writing rules held the reply text below. The user did not see it.",
+    ...held.map(({ reply, feedback }) => `<held-reply>\n${reply}\n</held-reply>\n\n${feedback}`),
+    "Write the full reply again. Correct each violation. Do not mention this message.",
+  ].join("\n\n")
+
+export async function* holdReply(
+  $: HoldApi,
+  e: StepEvent,
+  next: StepNext,
+): AsyncGenerator<Piece, StepResult> {
+  if (e.agentId !== undefined) return yield* next(e)
+  if (turn.id !== e.turnId) turn = { id: e.turnId, blocks: 0, held: [], lastStepHeld: false }
+  turn.lastStepHeld = false
+  if (turn.blocks >= BLOCK_LIMIT || !(await strictSession($))) return yield* next(e)
+
+  const { pieces, result } = await readAll(next(e))
+  if (next.signal.aborted) return result
+  if (result.answer.trim() === "") {
+    yield* pieces
+    return result
+  }
+
+  let feedback: string | undefined
+  try {
+    feedback = await replyFeedback($, result.answer)
+  } catch (error) {
+    if (next.signal.aborted) return result
+    const cause = error instanceof Error ? error.message : String(error)
+    $.ui.log(`Writing-rule reply check error: ${cause}. The reply is allowed.`)
+  }
+  if (next.signal.aborted) return result
+  if (feedback === undefined) {
+    yield* pieces
+    return result
+  }
+
+  turn.held.push({ reply: result.answer, feedback })
+  turn.lastStepHeld = true
+  yield* noticePieces(pieces)
+  return result
+}
+
+export async function* restoreReply(
+  _$: unknown,
+  e: StepEvent,
+  next: StepNext & { readonly called: boolean },
+): AsyncGenerator<Piece, StepResult> {
+  if (!next.called) return yield* next(e)
+  const { result } = await readAll(next(e))
+  if (next.signal.aborted) return result
+  if (result.answer !== "") yield { kind: "text", index: 0, text: result.answer }
+  for (const [offset, use] of result.toolUses.entries()) {
+    const index = offset + 1
+    yield { kind: "tool", index, id: `toolu_hold_${e.turnId}_${e.index}_${index}`, name: use.name }
+    yield { kind: "input", index, json: JSON.stringify(use.input) }
+  }
+  yield { kind: "stop", stopReason: result.stopReason, usage: result.usage }
+  return result
+}
+
+export async function blockHeldReply(
+  _$: unknown,
+  e: unknown,
+  next: (e: unknown) => Promise<StopResult>,
+): Promise<StopResult> {
+  const held = turn.held.splice(0)
+  if (!turn.lastStepHeld) return next(e)
+  turn.lastStepHeld = false
+  turn.blocks += 1
+  return { block: blockReason(held) }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-simple-english",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Technical and house-style English lint engine, CLI, and host adapters",
   "license": "MIT",
   "type": "module",
@@ -40,7 +40,7 @@
   "scripts": {
     "test": "vitest run",
     "bench:markdown": "vitest bench test/engine/markdown.bench.ts",
-    "lint": "biome check .",
+    "lint": "biome check . && bun scripts/check-no-comments.ts",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
@@ -48,6 +48,7 @@
     "@lezer/markdown": "^1.7.2",
     "effect": "4.0.1",
     "micromark": "^4.0.2",
+    "micromark-core-commonmark": "^2.0.3",
     "micromark-extension-frontmatter": "^2.0.0",
     "micromark-extension-gfm-table": "^2.1.1",
     "micromark-util-character": "^2.1.1",

package/src/cli/hook.ts

@@ -105,14 +105,14 @@ export type HookOutput =
   | StopDecision
   | Record<string, never>
 
-function record(value: unknown, name: string): Record<string, unknown> {
+export function record(value: unknown, name: string): Record<string, unknown> {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(`${name} must be a JSON object`)
   }
   return value as Record<string, unknown>
 }
 
-function stringField(value: Record<string, unknown>, name: string): string {
+export function stringField(value: Record<string, unknown>, name: string): string {
   const field = value[name]
   if (typeof field !== "string") throw new Error(`${name} must be a string`)
   return field
@@ -441,7 +441,7 @@ const takePendingFeedback = (sessionId: string) =>
 const readSessionControl = (sessionId: string) =>
   tryAsync("cannot read session state", () => getSessionControl(sessionId))
 
-const loadLintOptions = (cwd: string, tagger: Tagger) =>
+export const loadLintOptions = (cwd: string, tagger: Tagger) =>
   Effect.gen(function* () {
     const config = yield* loadConfig(undefined, cwd)
     const dictionaryPath = process.env.SIMPLE_ENGLISH_DICTIONARY

package/src/cli/main.ts

@@ -13,6 +13,7 @@ import type { LintKind, LintReport } from "../engine/types.ts"
 import { makeLazyWinkTagger } from "../tagger/wink.ts"
 import { hookInternalFailure, runHookMode } from "./hook.ts"
 import { observationStats, reviewObservations } from "./observation-log.ts"
+import { runReplyCheck } from "./reply-check.ts"
 import { runSessionCommand } from "./session-command.ts"
 import { tryAsync } from "./try-async.ts"
 
@@ -61,8 +62,7 @@ const argumentError = (cause: unknown): Error => {
   return new Error(error.message)
 }
 
-// parseArgs accepts "--kind --json" with "--json" as the value. Reject that.
-const rejectOptionValue = (values: CliArgs): Effect.Effect<void, Error> => {
+const rejectFlagAsOptionValue = (values: CliArgs): Effect.Effect<void, Error> => {
   if (values.config?.startsWith("--"))
     return Effect.fail(new Error("--config requires a file path"))
   if (values.kind?.startsWith("--")) {
@@ -157,6 +157,11 @@ const hookProgram = Effect.gen(function* () {
   ),
 )
 
+const replyCheckProgram = Effect.gen(function* () {
+  console.log(JSON.stringify(yield* runReplyCheck(yield* readStdin, tagger)))
+  return 0
+})
+
 const sessionProgram = Effect.gen(function* () {
   console.log(yield* runSessionCommand(args.slice(1)))
   return 0
@@ -180,7 +185,7 @@ const lintProgram = Effect.gen(function* () {
     try: () => parseCliArgs(args),
     catch: argumentError,
   })
-  yield* rejectOptionValue(values)
+  yield* rejectFlagAsOptionValue(values)
   const { json = false, config: configPath, kind, help, version } = values
   if (help) {
     console.log(USAGE)
@@ -251,11 +256,13 @@ const lintProgram = Effect.gen(function* () {
 const program: Effect.Effect<number, Error> =
   args[0] === "hook"
     ? rejectUnknownFlags(args.slice(1)).pipe(Effect.andThen(hookProgram))
-    : args[0] === "session"
-      ? rejectUnknownFlags(args.slice(1)).pipe(Effect.andThen(sessionProgram))
-      : args[0] === "observe"
-        ? observeProgram
-        : lintProgram
+    : args[0] === "reply-check"
+      ? rejectUnknownFlags(args.slice(1)).pipe(Effect.andThen(replyCheckProgram))
+      : args[0] === "session"
+        ? rejectUnknownFlags(args.slice(1)).pipe(Effect.andThen(sessionProgram))
+        : args[0] === "observe"
+          ? observeProgram
+          : lintProgram
 
 const handled = program.pipe(
   Effect.catch((error) =>

package/src/cli/reply-check.ts

@@ -0,0 +1,43 @@
+import { Effect } from "effect"
+import { formatViolations, splitViolations } from "../adapter/feedback.ts"
+import { lint } from "../engine/lint.ts"
+import type { Tagger } from "../engine/tagger.ts"
+import { loadLintOptions, record, stringField } from "./hook.ts"
+import { appendObservation } from "./observation-log.ts"
+
+export interface ReplyCheck {
+  readonly feedback?: string
+}
+
+export function runReplyCheck(raw: string, tagger: Tagger): Effect.Effect<ReplyCheck, Error> {
+  return Effect.gen(function* () {
+    const { sessionId, cwd, text } = yield* Effect.try({
+      try: () => {
+        const request = record(JSON.parse(raw) as unknown, "request")
+        return {
+          sessionId: stringField(request, "session_id"),
+          cwd: stringField(request, "cwd"),
+          text: stringField(request, "text"),
+        }
+      },
+      catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+    })
+    const violations = lint("prose-file", text, yield* loadLintOptions(cwd, tagger)).violations
+    const { hard } = splitViolations(violations)
+    if (hard.length === 0) return {}
+    yield* Effect.tryPromise(() =>
+      appendObservation({
+        event: "reply",
+        kind: "prose-file",
+        decision: "deny",
+        sessionId,
+        cwd,
+        text,
+        violations,
+      }),
+    ).pipe(Effect.catch(() => Effect.void))
+    return {
+      feedback: formatViolations("assistant reply", "Writing rules blocked reply for", hard),
+    }
+  })
+}

package/src/config/schema.ts

@@ -3,6 +3,7 @@ import type { RuleDataExtensions } from "../dictionary/rule-data.ts"
 import { type RuleId, ruleIds } from "../engine/rules/registry.ts"
 import type { RuleSetting } from "../engine/types.ts"
 import {
+  DECODE_OPTIONS_THAT_REPORT_REJECTED_VALUE,
   formatParseErrorIssues,
   formatParseErrorTree,
   type ParseError,
@@ -25,8 +26,6 @@ const RulesSchema = Schema.Struct(
   Object.fromEntries(ruleIds.map((id) => [id, Schema.optionalKey(RuleSettingSchema)])),
 )
 
-// One refinement over Unknown, rather than Number plus two checks, so that a
-// wrong type and a wrong number both report the same text and the value.
 const MaxSentenceWordsSchema = Schema.Unknown.pipe(
   Schema.refine(
     (value): value is number => typeof value === "number" && Number.isInteger(value) && value > 0,
@@ -51,12 +50,10 @@ const SteConfigSchema = Schema.Struct({
   approvedWordsPath: Schema.optionalKey(NonEmptyTrimmedString),
 })
 
-const decodeUnknown = Schema.decodeUnknownEffect(SteConfigSchema, {
-  onExcessProperty: "error",
-  errors: "all",
-  // v4 omits the rejected value from an issue unless this option is on.
-  reportInput: true,
-})
+const decodeUnknown = Schema.decodeUnknownEffect(
+  SteConfigSchema,
+  DECODE_OPTIONS_THAT_REPORT_REJECTED_VALUE,
+)
 
 export class ConfigError extends Error {
   readonly _tag = "ConfigError"

package/src/dictionary/bundled-rule-data.ts

@@ -5,8 +5,10 @@ import phrasalVerbs from "./data/phrasal-verbs.json" with { type: "json" }
 import type { RuleDataId } from "./rule-data.ts"
 import { type Dictionary, decodeDictionaryData } from "./schema.ts"
 
-// Jiti adds a non-enumerable default property that strict schema validation rejects.
-const decodeBundledDictionary = (data: object) => decodeDictionaryData({ ...data })
+const withoutJitiDefaultProperty = (data: object): object => ({ ...data })
+
+const decodeBundledDictionary = (data: object) =>
+  decodeDictionaryData(withoutJitiDefaultProperty(data))
 
 export const BUNDLED_RULE_DATA: Readonly<Record<RuleDataId, Dictionary>> = {
   "phrasal-verb": decodeBundledDictionary(phrasalVerbs),

package/src/dictionary/load.ts

@@ -2,7 +2,11 @@ import { readFile } from "node:fs/promises"
 import { resolve } from "node:path"
 import { fileURLToPath } from "node:url"
 import { Effect, Schema } from "effect"
-import { formatParseErrorIssues, type ParseError } from "../schema/parse-error.ts"
+import {
+  DECODE_OPTIONS_THAT_REPORT_REJECTED_VALUE,
+  formatParseErrorIssues,
+  type ParseError,
+} from "../schema/parse-error.ts"
 import { BUNDLED_RULE_DATA } from "./bundled-rule-data.ts"
 import type { RuleData, RuleDataExtensions, RuleDataId } from "./rule-data.ts"
 import {
@@ -41,14 +45,14 @@ const formatParseError = (error: ParseError): string => {
   return path === "" ? `invalid dictionary data: ${issue.message}` : `${path}: ${issue.message}`
 }
 
-// v4 omits the rejected value from an issue unless reportInput is on.
-const decodeOptions = { onExcessProperty: "error", errors: "all", reportInput: true } as const
-
-const decodeDictionary = Schema.decodeEffect(Schema.fromJsonString(DictionarySchema), decodeOptions)
+const decodeDictionary = Schema.decodeEffect(
+  Schema.fromJsonString(DictionarySchema),
+  DECODE_OPTIONS_THAT_REPORT_REJECTED_VALUE,
+)
 
 const decodeApprovedWordList = Schema.decodeEffect(
   Schema.fromJsonString(ApprovedWordListSchema),
-  decodeOptions,
+  DECODE_OPTIONS_THAT_REPORT_REJECTED_VALUE,
 )
 
 const readDictionaryFile = (

package/src/engine/case-fold.ts

@@ -6,8 +6,6 @@ export interface CaseFoldedToken {
   readonly offset: number
 }
 
-// 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[] =>

package/src/engine/diff.ts

@@ -128,11 +128,6 @@ function retainCharacters(
   )
 }
 
-/**
- * Character ranges that survive unchanged between two texts, in document order.
- * Line-level LCS first, then character-level LCS inside changed line chunks,
- * with a cell budget that falls back to prefix and suffix matching on huge edits.
- */
 export function retainedRanges(previousText: string, currentText: string): RetainedRange[] {
   const previous = lineTokens(previousText)
   const current = lineTokens(currentText)