agent-simple-english 0.6.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.6.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.6.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
@@ -73,6 +74,11 @@ The `/ase` command controls the current Claude Code session.
 New sessions start in enabled mode without a strict reply gate.
 A change in one session does not change a parallel session.
 
+The full command name is `/simple-english:ase`, and it always runs.
+The short name `/ase` runs the same command.
+If a user command or a project command has the name `ase`, that command takes the short name.
+Then use the full name.
+
 | Command | Result |
 | --- | --- |
 | `/ase on` | Enable write, edit, commit, and reply checks. |
@@ -82,13 +88,44 @@ A change in one session does not change a parallel session.
 | `/ase strict off` | Disable the strict reply gate and use reply feedback. |
 | `/ase explain` | Write the last reply again in Simplified Technical English. |
 
-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.
-
-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.
+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`.
+
+### Strict reply hold
+
+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.
+
+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
 
@@ -132,7 +169,7 @@ pi -e .
 
 The mode applies to the current pi session.
 The extension starts in enabled mode without strict reply gating.
-Type `/ase ` to see autocomplete suggestions for `on`, `off`, `status`, and `strict`.
+Type `/ase ` to see autocomplete suggestions for `on`, `off`, `status`, `strict`, and `strict off`.
 The list changes to match the text that you type.
 
 | Command | Result |
@@ -171,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.
@@ -454,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`
@@ -480,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/commands/ase.md

@@ -1,4 +1,5 @@
 ---
+name: ase
 description: Control writing-rule enforcement for this Claude Code session
 argument-hint: on|off|status|strict|strict off|explain
 allowed-tools: Bash

package/hooks/hooks.json

@@ -1,5 +1,7 @@
 {
-  "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"],
 
   "hooks": {
     "SessionStart": [

package/hooks/register.ts

@@ -0,0 +1,61 @@
+import { blockHeldReply, holdReply, restoreReply } from "./reply-hold.ts"
+
+interface Suggestion {
+  readonly text: string
+  readonly description: string
+}
+
+interface AutocompleteInput {
+  readonly text: string
+  readonly token: string
+  readonly start: number
+}
+
+interface AutocompleteResult {
+  readonly suggestions: readonly Suggestion[]
+}
+
+type AutocompleteHook = (
+  engine: unknown,
+  input: AutocompleteInput,
+  next: (input: AutocompleteInput) => Promise<AutocompleteResult>,
+) => Promise<AutocompleteResult>
+
+const FIRST_WORDS: readonly Suggestion[] = [
+  { text: "on", description: "Enable write, edit, commit, and reply checks" },
+  { text: "off", description: "Disable all checks and leave strict mode" },
+  { text: "status", description: "Show the mode, rule counts, and dictionary state" },
+  { text: "strict", description: "Enable the strict reply gate and all other checks" },
+  { text: "explain", description: "Write the last reply again in Simplified Technical English" },
+]
+
+const WORDS_AFTER_STRICT: readonly Suggestion[] = [
+  { text: "off", description: "Disable the strict reply gate and use reply feedback" },
+]
+
+export function aseSuggestions(text: string, token: string, start: number): readonly Suggestion[] {
+  const head = /^\/(?:simple-english:)?ase\s+(.*)$/u.exec(text.slice(0, start))
+  if (head === null) return []
+  const earlierWords = (head[1] ?? "").trim().toLowerCase()
+  const words =
+    earlierWords === "" ? FIRST_WORDS : earlierWords === "strict" ? WORDS_AFTER_STRICT : []
+  const typed = token.toLowerCase()
+  return words.filter((word) => word.text.startsWith(typed) && word.text !== typed)
+}
+
+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.6.0",
+  "version": "0.8.0",
   "description": "Technical and house-style English lint engine, CLI, and host adapters",
   "license": "MIT",
   "type": "module",
@@ -40,14 +40,15 @@
   "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": {
     "@lezer/html": "^1.3.12",
     "@lezer/markdown": "^1.7.2",
-    "effect": "4.0.0-rc.112",
+    "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)