hook-dsh-normalize-dash

Family position (the @-sentence Hook @ DSH @ Normalize @ Dash): a hook child of the plugin-dsh-factory service and the hook-dsh-core machinery; the first of six stream normalizer siblings, all built on the shared machinery:

It is also the factory's first NON-MANIFEST module: it injects ["pluginFactory"] and uses only State (cell unwrap + shared Ledger/Enabled mappings + its own fields) and Append. It touches no files, so fs/write-intent and fs/observed never see it; it wraps the downstream result and always calls next(), so it composes with other llm/stream listeners regardless of registration order. Untouched chunks pass through by object identity; a rewritten delta/block is a shallow copy with only the text field replaced.

The user's hermes hook rewrites the unicode dash family to ASCII hyphen-minus in files after the fact - perl -CSD -pe over whatever was already written. Model output, however, is born in the stream: the live UI and the durable transcript see the em dashes first, no matter what a file hook does later. A DSH plugin can go where hermes cannot: the llm/stream waterfall, where every streaming model call passes through.

Unlike the governance family (hook-dsh-governor-package, hook-dsh-pinner-package, hook-dsh-governor-cargo), whose rewrites are SILENT, this plugin's normalization is deliberately VISIBLE - it IS the feature: the rewrite flows into both the live UI and the durable transcript.

Waterfall discipline: next() is ALWAYS called, unconditionally, first - omitting it short-circuits the waterfall and the model call never happens; options is NEVER touched (a loop-built request arrives deep-frozen and its content is a pure function of the session log); order preserved, no buffering - one chunk in, one chunk out, upstream throws propagate.

The transform - exactly the hermes hook's perl pattern ( perl -CSD -pe in normalize-dashes.sh), applied per text segment - the core's Dashes class, verbatim:

Armenian hyphen, Hebrew maqaf, Canadian syllabics hyphen, Mongolian todo soft hyphen, the U+2010-U+2015 hyphen/dash family (including the em dash and the non-breaking hyphen), double oblique hyphen, hyphen with diaeresis, two-/three-em dash, double hyphen, U+2E5D, wave/wavy dash, katakana-hiragana double hyphen, the vertical presentation dashes, small em dash, small hyphen-minus and the fullwidth hyphen-minus - all become the config replacement (default -, ASCII hyphen-minus U+002D). No context rules - hermes has none. Chunk-boundary-safe: single-character replacement, no lookahead, no multi-character sequences - per-chunk application can never disagree with whole-text application. The replacement is applied with a function replacer, so a custom replacement containing $ patterns is inserted literally. Replaced characters are counted per stream for the ledger line.

Besides the stream listener, the normalize-dash registers the family's raw-write tool: a plugin-registered write wrapper that wraps the built-in write operation with an explicit normalize parameter - the tool is exempt from the stream normalization by name (the core's Stream/Chunk + Stream/Block pass every raw-write call through by identity, exactly like edit), so the content is what the model sent, and the normalization decision happens at execution time:

The tool also takes a govern parameter - the per-call governance selection over the factory's direct-govern registry, applied after a successful write: absent or false (default) runs NO governance chain (the write still emits fs/observed exactly like a built-in write); true or "all" runs ALL registered governance steps for the target's basename; ["canonicalize", ...] runs ONLY the named steps. Governance is best-effort and contained: the steps run through the factory's Govern(target, selection, actor, version) with the written outcome's fresh version - a failing step never affects the write's outcome. The exec mirrors the built-in write's fs path exactly -ctx.fs.resolve → the fs/write-intent waterfall → the standing sandbox policy → ctx.fs.writeText(...) → the fs/observed emit with the written version. exec.signal is honored end to end. Inject: ["pluginFactory", "fs", "tools"].

A sample of the core's Dashes class - the full class is the hermes perl pattern verbatim, every entry mapping to the config replacement (default U+002D):

Volatile cells commit without remounting the plugin (the fiber - and with it the llm/stream registration - stays alive); the factory's State builder unwraps them defensively. Example cordis.patch.yml row:

The model emits prose with typographic dashes; the live UI and the transcript receive the ASCII forms:

Before - the model stream as it is born

The em dash (U+2014), the en dash (U+2013) and the horizontal bar (U+2015) each become -; the ASCII hyphens that were already there are untouched (the count only counts replacements). The same pass runs over reasoning deltas ( normalizeReasoning, default on) and - with the example patch enabling normalizeToolArguments - over tool-call arguments, where the three-way gate keeps the sensitive calls intact:

After - the stream that reaches the transcript (and the gate for sensitive calls)

And the raw-write tool in the file-writing direction: its content lands verbatim by default, or runs the family's six-fold chain when called with normalize: true - the em dash above would survive the default call and become a hyphen under normalize: true. The selection can also be FINE-GRAINED:

The raw-write tool, per call

The order is FIXED by the family (dashes → quotes → ellipsis → spaces → invisible → fullwidth) even when the selection lists the flavors out of order: normalize: ["fullwidth", "dash"] still applies dashes first. And the governance direction, per call: a raw-write to a package.json with govern: true runs the registered chain pass (canonicalize) and the update stage after the write lands; govern: ["pin"] runs only the pinner's chain pass. When a stream finishes normally with replacements made, the ledger gets the count line shown below.

Two lines, both written through the factory's Append (the hook-dsh-normalize-dash: prefix is the logger's <State.Module>:; the durable file line is [<ISO>] <message>):

The activation line is written by apply(); the count line only follows a normal stream completion and only when N > 0 (a thrown-away stream writes no ledger line).

License: MIT. The workbench and the matrix pages run the same flavors live.