agent-simple-english 0.4.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.4.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.4.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.4.0",
+  "version": "0.5.1",
   "description": "Technical and house-style English lint engine, CLI, and host adapters",
   "license": "MIT",
   "type": "module",
@@ -46,7 +46,7 @@
   "dependencies": {
     "@lezer/html": "^1.3.12",
     "@lezer/markdown": "^1.7.2",
-    "effect": "^3.14.0",
+    "effect": "4.0.0-rc.112",
     "micromark": "^4.0.2",
     "micromark-extension-frontmatter": "^2.0.0",
     "micromark-extension-gfm-table": "^2.1.1",
@@ -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
@@ -715,7 +633,7 @@ function recordEvaluation(event: HookEvent, evaluation: HookEvaluation): Effect.
       }),
     catch: () => undefined,
   }).pipe(
-    Effect.catchAll(() => Effect.void),
+    Effect.catch(() => Effect.void),
     Effect.as(evaluation.output),
   )
 }
@@ -760,14 +678,14 @@ export function runHookMode(raw: string): Effect.Effect<HookOutput, never, Tagge
               return yield* recordEvaluation(event, evaluation)
             })
           }),
-          Effect.catchAll((error) =>
+          Effect.catch((error) =>
             Effect.succeed(
               event.hookEventName === "PreToolUse"
                 ? nonBlockingWarning(error.message)
                 : nonBlockingError(error.message),
             ),
           ),
-          Effect.catchAllCause((cause) =>
+          Effect.catchCause((cause) =>
             Effect.succeed(
               event.hookEventName === "PreToolUse"
                 ? hookInternalFailure(cause)

package/src/cli/main.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env bun
 import { readFile } from "node:fs/promises"
-import { Effect, Either } from "effect"
+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,
   }
@@ -164,7 +164,7 @@ const hookProgram = Effect.gen(function* () {
   console.log(JSON.stringify(output))
   return 0
 }).pipe(
-  Effect.catchAllCause((cause) =>
+  Effect.catchCause((cause) =>
     Effect.sync(() => {
       console.log(JSON.stringify(hookInternalFailure(cause)))
       return 0
@@ -220,20 +220,20 @@ const lintProgram = Effect.gen(function* () {
     )
   }
   const config = yield* loadConfig(configPath)
-  const loadedDictionary = yield* Effect.either(
+  const loadedDictionary = yield* Effect.result(
     loadConfiguredDictionary(config, process.cwd(), process.env.SIMPLE_ENGLISH_DICTIONARY),
   )
-  const loadedRuleData = yield* Effect.either(loadRuleData(config.ruleDataExtensions))
-  if (Either.isLeft(loadedDictionary) && config.approvedWordsPath !== undefined) {
-    return yield* Effect.fail(loadedDictionary.left)
+  const loadedRuleData = yield* Effect.result(loadRuleData(config.ruleDataExtensions))
+  if (Result.isFailure(loadedDictionary) && config.approvedWordsPath !== undefined) {
+    return yield* Effect.fail(loadedDictionary.failure)
   }
-  const dictionary = Either.getOrUndefined(loadedDictionary)
-  const ruleData = Either.getOrUndefined(loadedRuleData)
-  if (Either.isLeft(loadedDictionary)) {
-    yield* Effect.sync(() => console.error(loadedDictionary.left.message))
+  const dictionary = Result.getOrUndefined(loadedDictionary)
+  const ruleData = Result.getOrUndefined(loadedRuleData)
+  if (Result.isFailure(loadedDictionary)) {
+    yield* Effect.sync(() => console.error(loadedDictionary.failure.message))
   }
-  if (Either.isLeft(loadedRuleData)) {
-    yield* Effect.sync(() => console.error(loadedRuleData.left.message))
+  if (Result.isFailure(loadedRuleData)) {
+    yield* Effect.sync(() => console.error(loadedRuleData.failure.message))
   }
   const inputs =
     paths.length === 0
@@ -282,7 +282,7 @@ const program: Effect.Effect<number, Error> =
         : lintProgram.pipe(Effect.provide(WinkTaggerLive))
 
 const handled = program.pipe(
-  Effect.catchAll((error) =>
+  Effect.catch((error) =>
     Effect.sync(() => {
       console.error(error.message)
       return 2

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-command.ts

@@ -1,5 +1,5 @@
 import { resolve } from "node:path"
-import { Effect, Either } from "effect"
+import { Effect, Result } from "effect"
 import { formatFailedStatusSummary, formatStatusSummary } from "../adapter/rule-summary.ts"
 import { loadConfig } from "../config/load.ts"
 import { loadConfiguredDictionary } from "../dictionary/configured.ts"
@@ -48,25 +48,25 @@ const updateStrict = (sessionId: string, strict: boolean) =>
 function status(sessionId: string, cwd: string): Effect.Effect<string, Error> {
   return Effect.gen(function* () {
     const control = yield* readControl(sessionId)
-    const configResult = yield* Effect.either(loadConfig(undefined, cwd))
-    if (Either.isLeft(configResult)) {
-      return formatFailedStatusSummary(modeName(control), configResult.left.message)
+    const configResult = yield* Effect.result(loadConfig(undefined, cwd))
+    if (Result.isFailure(configResult)) {
+      return formatFailedStatusSummary(modeName(control), configResult.failure.message)
     }
     const dictionaryPath = process.env.SIMPLE_ENGLISH_DICTIONARY
-    const dictionaryResult = yield* Effect.either(
+    const dictionaryResult = yield* Effect.result(
       Effect.all({
         dictionary: loadConfiguredDictionary(
-          configResult.right,
+          configResult.success,
           cwd,
           dictionaryPath === undefined ? undefined : resolve(cwd, dictionaryPath),
         ),
-        ruleData: loadRuleData(configResult.right.ruleDataExtensions, cwd),
+        ruleData: loadRuleData(configResult.success.ruleDataExtensions, cwd),
       }),
     )
-    const dictionary: DictionaryState = Either.isRight(dictionaryResult)
+    const dictionary: DictionaryState = Result.isSuccess(dictionaryResult)
       ? "loaded"
-      : `failed (${dictionaryResult.left.message})`
-    return formatStatusSummary(configResult.right, modeName(control), dictionary)
+      : `failed (${dictionaryResult.failure.message})`
+    return formatStatusSummary(configResult.success, modeName(control), dictionary)
   })
 }
 

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/config/schema.ts

@@ -1,7 +1,13 @@
-import { Effect, ParseResult, Schema } from "effect"
+import { Effect, Schema } from "effect"
 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 {
+  formatParseErrorIssues,
+  formatParseErrorTree,
+  type ParseError,
+} from "../schema/parse-error.ts"
+import { NonEmptyTrimmedString } from "../schema/primitives.ts"
 
 export interface SteConfig {
   readonly rules?: Partial<Readonly<Record<RuleId, RuleSetting>>>
@@ -11,63 +17,53 @@ export interface SteConfig {
   readonly approvedWordsPath?: string
 }
 
-const RuleSettingSchema = Schema.Literal("hard", "soft", "off").annotations({
-  message: (issue) => ({
-    message: `must be "hard", "soft", or "off", got ${JSON.stringify(issue.actual)}`,
-    override: true,
-  }),
+const RuleSettingSchema = Schema.Literals(["hard", "soft", "off"]).annotate({
+  expected: '"hard", "soft", or "off"',
 })
 
-const RulesSchema = Schema.partial(
-  Schema.Struct(Object.fromEntries(ruleIds.map((id) => [id, RuleSettingSchema]))),
+const RulesSchema = Schema.Struct(
+  Object.fromEntries(ruleIds.map((id) => [id, Schema.optionalKey(RuleSettingSchema)])),
 )
 
-const MaxSentenceWordsSchema = Schema.Int.pipe(Schema.positive()).annotations({
-  message: (issue) => ({
-    message: `must be a positive integer, got ${JSON.stringify(issue.actual)}`,
-    override: true,
-  }),
-})
+// 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,
+    { expected: "a positive integer" },
+  ),
+)
 
-const ExemptBlockQuotesSchema = Schema.Boolean.annotations({
-  message: (issue) => ({
-    message: `must be a boolean, got ${JSON.stringify(issue.actual)}`,
-    override: true,
-  }),
-})
+const ExemptBlockQuotesSchema = Schema.Boolean
 
-const RuleDataExtensionsSchema = Schema.partial(
-  Schema.Struct({
-    "phrasal-verb": Schema.Array(Schema.NonEmptyTrimmedString),
-    hedging: Schema.Array(Schema.NonEmptyTrimmedString),
-    marketing: Schema.Array(Schema.NonEmptyTrimmedString),
-    "adjectival-participle": Schema.Array(Schema.NonEmptyTrimmedString),
-  }),
-)
+const RuleDataExtensionsSchema = Schema.Struct({
+  "phrasal-verb": Schema.optionalKey(Schema.Array(NonEmptyTrimmedString)),
+  hedging: Schema.optionalKey(Schema.Array(NonEmptyTrimmedString)),
+  marketing: Schema.optionalKey(Schema.Array(NonEmptyTrimmedString)),
+  "adjectival-participle": Schema.optionalKey(Schema.Array(NonEmptyTrimmedString)),
+})
 
 const SteConfigSchema = Schema.Struct({
-  rules: Schema.optional(RulesSchema),
-  maxSentenceWords: Schema.optional(MaxSentenceWordsSchema),
-  exemptBlockQuotes: Schema.optional(ExemptBlockQuotesSchema),
-  ruleDataExtensions: Schema.optional(RuleDataExtensionsSchema),
-  approvedWordsPath: Schema.optional(Schema.NonEmptyTrimmedString),
+  rules: Schema.optionalKey(RulesSchema),
+  maxSentenceWords: Schema.optionalKey(MaxSentenceWordsSchema),
+  exemptBlockQuotes: Schema.optionalKey(ExemptBlockQuotesSchema),
+  ruleDataExtensions: Schema.optionalKey(RuleDataExtensionsSchema),
+  approvedWordsPath: Schema.optionalKey(NonEmptyTrimmedString),
 })
 
-const decodeUnknown = Schema.decodeUnknown(SteConfigSchema, {
+const decodeUnknown = Schema.decodeUnknownEffect(SteConfigSchema, {
   onExcessProperty: "error",
   errors: "all",
+  // v4 omits the rejected value from an issue unless this option is on.
+  reportInput: true,
 })
 
 export class ConfigError extends Error {
   readonly _tag = "ConfigError"
 }
 
-const formatError = (error: ParseResult.ParseError, source: string): string => {
-  // Optional fields decode as `T | undefined` unions, so every failure also
-  // reports a useless "Expected undefined" branch; drop those.
-  const issues = ParseResult.ArrayFormatter.formatErrorSync(error).filter(
-    (issue) => !issue.message.startsWith("Expected undefined"),
-  )
+const formatError = (error: ParseError, source: string): string => {
+  const issues = formatParseErrorIssues(error)
   const lines = [
     ...new Set(
       issues.map(
@@ -78,7 +74,7 @@ const formatError = (error: ParseResult.ParseError, source: string): string => {
   const detail =
     lines.length > 0
       ? lines.map((line) => `  ${line}`).join("\n")
-      : `  ${ParseResult.TreeFormatter.formatErrorSync(error)}`
+      : `  ${formatParseErrorTree(error)}`
   return `invalid config in ${source}:\n${detail}`
 }