fix(hooks): reuse compiled Codex matchers

packages/hooks/hook-protocol/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/hooks/hook-protocol/README.md
-README.md: e8e3e1b078f74636ee23f90a96d1e8748d7af373
-README.zh.md: 4671b179b222eea68cbcb00042d2ddcfe9a5691f
+README.md: 1b4c6c3b73b0d4f3d5df06405d27b94652b6c686
+README.zh.md: 5b55034ff136129f83ae90a84b8efc89affcfce0

packages/hooks/hook-protocol/README.md

@@ -10,7 +10,7 @@ Why a shared lib at all: Codex deliberately reimplements a *subset* of the Claud
 
 | Concern | Here (`dsh-hook-protocol`) | The bridge (`dsh-hooks-claude` / `-codex`) |
 |---|---|---|
-| Matcher validation + test | `matcherDiagnostic(pattern, mode)` for parse-time diagnostics; `matchesMatcher(pattern, query, mode)` for contained runtime matching | picks its native regex `mode` (`claude` = JavaScript, `codex` = Rust `regex`) and rejects a config group carrying a diagnostic |
+| Matcher validation + test | `matcherDiagnostic(pattern, mode)` for parse-time diagnostics; `compileMatchers(patterns, mode)` for repeated config-lifetime matching; `matchesMatcher(pattern, query, mode)` for one-shot contained matching | picks its native regex `mode` (`claude` = JavaScript, `codex` = Rust `regex`), rejects a config group carrying a diagnostic, and disposes the compiled set on teardown |
 | Run a hook | `runHook(bash, hook, opts, now)` — stdin payload + env via `ctx.bash`, decode | builds the per-event stdin **payload** + the dialect's **env** |
 | Decode output | `parseHookOutput(exit, stdout, stderr)` → neutral `HookOutput` | maps the neutral `HookOutput` onto a seam-specific typed Decision |
 | Merge N hooks | `mergeHookOutputs(outputs)` → most-restrictive `MergedHookOutcome` | — |
@@ -19,7 +19,7 @@ Why a shared lib at all: Codex deliberately reimplements a *subset* of the Claud
 
 ## Primitives
 
-- **`matcherDiagnostic(matcher, mode)` / `matchesMatcher(matcher, query, mode)`** — match-all on absent/`''`/`'*'`; both dialects treat a pure `[A-Za-z0-9_|]+` pattern as exact pipe-separated alternatives. Other patterns are unanchored regexes compiled in the native dialect: JavaScript for Claude Code, Rust `regex` for Codex (including inline flags such as `(?i)`). Bridge parsers discard matcher fields for events without matcher subjects, then use `matcherDiagnostic` to reject an invalid consumed regex with a stable diagnostic before registering any hooks. The runtime predicate still contains an invalid pattern as a non-match, so a direct library caller cannot throw into the agent loop.
+- **`matcherDiagnostic(matcher, mode)` / `compileMatchers(matchers, mode)` / `matchesMatcher(matcher, query, mode)`** — match-all on absent/`''`/`'*'`; both dialects treat a pure `[A-Za-z0-9_|]+` pattern as exact pipe-separated alternatives. Other patterns are unanchored regexes compiled in the native dialect: JavaScript for Claude Code, Rust `regex` for Codex (including inline flags such as `(?i)`). Bridge parsers discard matcher fields for events without matcher subjects, then use `matcherDiagnostic` to reject an invalid consumed regex with a stable diagnostic before registering any hooks. Each bridge uses `compileMatchers` to compile every unique config pattern once, reuses it at every hook point, and disposes the finite set after detached runs drain on plugin teardown; this avoids the Rust/WASM allocator's non-shrinking high-water mark growing on every match. `matchesMatcher` remains the contained one-shot predicate, and invalid runtime patterns are non-matches rather than exceptions.
 - **`runHook(bash, hook, options, now)`** — require and forward the caller-owned `options.signal`, serialize `options.payload` to the hook's stdin (with a trailing newline iff `options.trailingNewline`), merge `options.env` after the executor's credential scrub (the `dsh-bash` trusted-plugin surface), honor the hook's `timeoutSec` (else `options.defaultTimeoutMs` — the bridge owns the default, its config defaulting to the lib's `DEFAULT_HOOK_TIMEOUT_MS` 10-minute reference), and decode the result (threading `options.expectedEventName` to the codec). Cancellation therefore reaches the executor's process-group kill and join boundary. Never throws: an executor rejection (infra fault) becomes a `HookOutput` with `exitCode: undefined` (a non-blocking error). `now` is injected for testable durations.
 - **`parseHookOutput(exitCode, stdout, stderr, expectedEventName?)`** decodes exit status and structured stdout. Exit 2 blocks with stderr; other failures are non-blocking. A matching hook-specific permission decision overrides the legacy top-level decision; mismatched or missing event discriminators suppress only event-specific fields. Top-level fields remain event-agnostic, and successful non-JSON output is left to the bridge.
 - **`mergeHookOutputs(outputs)`** — fold the results of every hook that matched one point: permission precedence **deny > ask > allow**, halt sticky on the first `continue:false`, block reasons joined with `\n\n`, `additionalContext`/`systemMessages` accumulated in order.

packages/hooks/hook-protocol/README.zh.md

@@ -10,7 +10,7 @@ Claude Code／Codex hook 协议格式的**共享核心**。它不是 cordis 插
 
 | 关注点 | 此处（`dsh-hook-protocol`） | 桥接（`dsh-hooks-claude` / `-codex`） |
 |---|---|---|
-| Matcher 校验 + 测试 | `matcherDiagnostic(pattern, mode)` 用于解析时诊断；`matchesMatcher(pattern, query, mode)` 用于收敛的运行时匹配 | 选择自身原生正则 `mode`（`claude` = JavaScript，`codex` = Rust `regex`），并拒绝带有诊断的配置组 |
+| Matcher 校验 + 测试 | `matcherDiagnostic(pattern, mode)` 用于解析时诊断；`compileMatchers(patterns, mode)` 用于配置生命周期内的重复匹配；`matchesMatcher(pattern, query, mode)` 用于一次性的收敛匹配 | 选择自身原生正则 `mode`（`claude` = JavaScript，`codex` = Rust `regex`），拒绝带有诊断的配置组，并在 teardown 时释放已编译集合 |
 | 运行 hook | `runHook(bash, hook, opts, now)`：通过 `ctx.bash` 提供 stdin payload + env，再解码 | 构造每个事件的 stdin **payload** + 该方言的 **env** |
 | 解码输出 | `parseHookOutput(exit, stdout, stderr)` → 中性 `HookOutput` | 将中性 `HookOutput` 映射到 seam 特定的类型化 Decision |
 | 合并 N 个 hook | `mergeHookOutputs(outputs)` → 最严格的 `MergedHookOutcome` | （无） |
@@ -19,7 +19,7 @@ Claude Code／Codex hook 协议格式的**共享核心**。它不是 cordis 插
 
 ## 原语
 
-- **`matcherDiagnostic(matcher, mode)` / `matchesMatcher(matcher, query, mode)`**：缺失、`''` 或 `'*'` 时匹配全部；两种方言都将纯 `[A-Za-z0-9_|]+` pattern 视为按 pipe 分隔的精确多选。其他 pattern 会用原生方言编译为未锚定正则：Claude Code 使用 JavaScript，Codex 使用 Rust `regex`（包括 `(?i)` 等内联 flag）。桥接解析器会丢弃没有 matcher 匹配对象的事件所带 matcher 字段，再使用 `matcherDiagnostic` 在注册任何 hook 之前拒绝实际会被消费的无效正则，并输出稳定诊断。运行时谓词仍将无效 pattern 收敛为不匹配，因此直接库调用无法向 agent loop 抛出异常。
+- **`matcherDiagnostic(matcher, mode)` / `compileMatchers(matchers, mode)` / `matchesMatcher(matcher, query, mode)`**：缺失、`''` 或 `'*'` 时匹配全部；两种方言都将纯 `[A-Za-z0-9_|]+` pattern 视为按 pipe 分隔的精确多选。其他 pattern 会用原生方言编译为未锚定正则：Claude Code 使用 JavaScript，Codex 使用 Rust `regex`（包括 `(?i)` 等内联 flag）。桥接解析器会丢弃没有 matcher 匹配对象的事件所带 matcher 字段，再使用 `matcherDiagnostic` 在注册任何 hook 之前拒绝实际会被消费的无效正则，并输出稳定诊断。每个桥接通过 `compileMatchers` 将配置中每个唯一 pattern 只编译一次，在各 hook 点重复使用，并在插件 teardown 时先 drain 脱离运行，再释放这个有限集合；因此 Rust／WASM 分配器不会因每次匹配都抬高且无法收缩的内存高水位。`matchesMatcher` 保留为收敛的一次性谓词，运行时无效 pattern 仍是不匹配而非异常。
 - **`runHook(bash, hook, options, now)`**：要求并转发调用方拥有的 `options.signal`，将 `options.payload` 序列化到 hook stdin（当且仅当 `options.trailingNewline` 时添加尾随换行符），在执行器凭证清理后合并 `options.env`（`dsh-bash` 受信任插件表层），遵循 hook 的 `timeoutSec`（否则使用 `options.defaultTimeoutMs`；默认值属于桥接，其配置默认为 lib 的 `DEFAULT_HOOK_TIMEOUT_MS` 10 分钟参考值），再解码结果（将 `options.expectedEventName` 传递给 codec）。因此取消会到达执行器的进程组终止与 join 边界。它绝不抛出异常：执行器拒绝（基础设施故障）会变为 `HookOutput`，其 `exitCode: undefined`（非阻塞错误）。`now` 会被注入，以便测试持续时间。
 - **`parseHookOutput(exitCode, stdout, stderr, expectedEventName?)`** 解码退出状态与结构化 stdout。退出码 2 使用 stderr 阻塞；其他失败不阻塞。匹配的 hook 特定权限决策会覆盖遗留顶层决策；事件判别字段不匹配或缺失只会抑制事件特定字段。顶层字段仍与事件无关，成功但非 JSON 的输出会留给桥接处理。
 - **`mergeHookOutputs(outputs)`**：折叠在一个点上匹配的每个 hook 结果：权限优先级为 **deny > ask > allow**，首个 `continue:false` 使 halt 粘滞，阻塞原因用 `\n\n` 连接，`additionalContext`／`systemMessages` 按顺序累积。

packages/hooks/hook-protocol/src/index.ts

@@ -13,7 +13,8 @@ export type {
   MatcherGroup,
   MatcherMode,
 } from './types.ts'
-export { matcherDiagnostic, matchesMatcher } from './matcher.ts'
+export { compileMatchers, matcherDiagnostic, matchesMatcher } from './matcher.ts'
+export type { CompiledMatchers } from './matcher.ts'
 export { parseHookOutput } from './codec.ts'
 export { DEFAULT_HOOK_TIMEOUT_MS, runHook } from './runner.ts'
 export type { RunHookOptions, RunHookResult } from './runner.ts'

packages/hooks/hook-protocol/src/matcher.ts

@@ -28,6 +28,19 @@ function isMatchAll(matcher: string | undefined): boolean {
 /** An exact pattern is purely word chars + `|` (the regex-vs-literal discriminator). */
 const EXACT_MATCHER = /^[A-Za-z0-9_|]+$/
 
+interface CompiledMatcher {
+  matches(query: string): boolean
+  dispose(): void
+}
+
+/** A config-lifetime matcher set compiled once and explicitly released. */
+export interface CompiledMatchers {
+  /** Match one of the patterns supplied to {@link compileMatchers}. */
+  matches(matcher: string | undefined, query: string): boolean
+  /** Release every native matcher. Safe to call more than once. */
+  dispose(): void
+}
+
 /** Compile one dialect's unanchored regex; invalid patterns return `undefined`. */
 function compileRegex(pattern: string, mode: MatcherMode): RegExp | RustRegex | undefined {
   try {
@@ -39,11 +52,55 @@ function compileRegex(pattern: string, mode: MatcherMode): RegExp | RustRegex |
   }
 }
 
-/** Release the WASM-backed Codex regex once a one-shot validation or match is done. */
+/** Release a WASM-backed Codex regex when its owning matcher lifetime ends. */
 function disposeRegex(regex: RegExp | RustRegex): void {
   if (regex instanceof RRegex) regex.free()
 }
 
+/** Compile one matcher into a reusable, explicitly disposable predicate. */
+function compileMatcher(matcher: string | undefined, mode: MatcherMode): CompiledMatcher {
+  if (isMatchAll(matcher)) return { matches: () => true, dispose: () => {} }
+  const pattern = matcher as string
+  if (EXACT_MATCHER.test(pattern)) {
+    const alternatives = new Set(pattern.split('|'))
+    return { matches: query => alternatives.has(query), dispose: () => {} }
+  }
+  const regex = compileRegex(pattern, mode)
+  if (regex === undefined) return { matches: () => false, dispose: () => {} }
+  return {
+    matches: query => regex instanceof RRegex ? regex.isMatch(query) : regex.test(query),
+    dispose: () => { disposeRegex(regex) },
+  }
+}
+
+/**
+ * Compile a finite config's unique matcher patterns for repeated evaluation.
+ * The returned registry owns native Rust-regex allocations; its caller must
+ * dispose it when the config/plugin lifetime ends.
+ * @param matchers - the complete finite set of patterns in one loaded config.
+ * @param mode - the native regex dialect used for non-literal patterns.
+ * @returns a reusable registry that owns and disposes its compiled regexes.
+ */
+export function compileMatchers(matchers: Iterable<string | undefined>, mode: MatcherMode): CompiledMatchers {
+  const compiled = new Map<string | undefined, CompiledMatcher>()
+  for (const matcher of matchers) {
+    if (!compiled.has(matcher)) compiled.set(matcher, compileMatcher(matcher, mode))
+  }
+  let disposed = false
+  return {
+    matches(matcher, query) {
+      if (disposed) return false
+      return compiled.get(matcher)?.matches(query) ?? false
+    },
+    dispose() {
+      if (disposed) return
+      disposed = true
+      for (const matcher of compiled.values()) matcher.dispose()
+      compiled.clear()
+    },
+  }
+}
+
 /**
  * Validate one matcher before a bridge accepts its config group.
  * @param matcher - configured pattern; match-all sentinels are valid.
@@ -73,17 +130,10 @@ export function matcherDiagnostic(matcher: string | undefined, mode: MatcherMode
  *   regex.
  */
 export function matchesMatcher(matcher: string | undefined, query: string, mode: MatcherMode): boolean {
-  if (isMatchAll(matcher)) return true
-  // matcher is a non-empty string past the match-all guard.
-  const pattern = matcher as string
-  if (EXACT_MATCHER.test(pattern)) {
-    return pattern.split('|').includes(query)
-  }
-  const regex = compileRegex(pattern, mode)
-  if (regex === undefined) return false
+  const compiled = compileMatcher(matcher, mode)
   try {
-    return regex instanceof RRegex ? regex.isMatch(query) : regex.test(query)
+    return compiled.matches(query)
   } finally {
-    disposeRegex(regex)
+    compiled.dispose()
   }
 }

packages/hooks/hook-protocol/tests/matcher-lifecycle.spec.ts

@@ -0,0 +1,45 @@
+import { createRequire } from 'node:module'
+import { describe, expect, it, vi } from 'vitest'
+import type { RRegex as RustRegex } from 'rregex'
+
+describe('compileMatchers — native regex lifecycle', () => {
+  it('constructs each unique Codex regex once across repeated matches and frees it once', async () => {
+    const require = createRequire(import.meta.url)
+    const rregex = require('rregex') as { RRegex: new(pattern: string) => RustRegex }
+    const OriginalRRegex = rregex.RRegex
+    const construct = vi.fn<(pattern: string) => void>()
+    const free = vi.fn<() => void>()
+
+    class CountingRRegex extends OriginalRRegex {
+      constructor(pattern: string) {
+        super(pattern)
+        construct(pattern)
+      }
+
+      override free(): void {
+        free()
+        super.free()
+      }
+    }
+
+    rregex.RRegex = CountingRRegex
+    vi.resetModules()
+    try {
+      const { compileMatchers } = await import('@deepseek-ai/dsh-hook-protocol/src/matcher.ts')
+      const matchers = compileMatchers(['(?i)^bash$', '(?i)^bash$', '^write$'], 'codex')
+      expect(construct.mock.calls.map(([pattern]) => pattern)).toEqual(['(?i)^bash$', '^write$'])
+
+      for (let i = 0; i < 1_000; i++) {
+        expect(matchers.matches('(?i)^bash$', 'BASH')).toBe(true)
+      }
+      expect(construct).toHaveBeenCalledTimes(2)
+
+      matchers.dispose()
+      matchers.dispose()
+      expect(free).toHaveBeenCalledTimes(2)
+    } finally {
+      rregex.RRegex = OriginalRRegex
+      vi.resetModules()
+    }
+  })
+})

packages/hooks/hook-protocol/tests/matcher.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { matcherDiagnostic, matchesMatcher } from '@deepseek-ai/dsh-hook-protocol'
+import { compileMatchers, matcherDiagnostic, matchesMatcher } from '@deepseek-ai/dsh-hook-protocol'
 
 describe('matchesMatcher — match-all sentinels (both dialects)', () => {
   for (const mode of ['claude', 'codex'] as const) {
@@ -82,3 +82,28 @@ describe('matcherDiagnostic — parse-time diagnostics', () => {
     expect(matcherDiagnostic('(?=Bash)', 'codex')).toBe('invalid codex regex matcher "(?=Bash)"')
   })
 })
+
+describe('compileMatchers — config-lifetime reuse', () => {
+  it('compiles a finite set, contains unknown patterns, and stops after disposal', () => {
+    const matchers = compileMatchers([undefined, 'Edit|Write', '(?i)^bash$', '['], 'codex')
+
+    expect(matchers.matches(undefined, 'anything')).toBe(true)
+    expect(matchers.matches('Edit|Write', 'Write')).toBe(true)
+    expect(matchers.matches('Edit|Write', 'WriteFile')).toBe(false)
+    expect(matchers.matches('(?i)^bash$', 'BASH')).toBe(true)
+    expect(matchers.matches('[', 'anything')).toBe(false)
+    expect(matchers.matches('not-compiled', 'not-compiled')).toBe(false)
+
+    matchers.dispose()
+    expect(matchers.matches(undefined, 'anything')).toBe(false)
+    expect(matchers.matches('(?i)^bash$', 'BASH')).toBe(false)
+    expect(() => { matchers.dispose() }).not.toThrow()
+  })
+
+  it('reuses JavaScript regexes too', () => {
+    const matchers = compileMatchers(['^Bash$', '^Bash$'], 'claude')
+    expect(matchers.matches('^Bash$', 'Bash')).toBe(true)
+    expect(matchers.matches('^Bash$', 'BashOutput')).toBe(false)
+    matchers.dispose()
+  })
+})