From 7743b397a6e72ed451e3bd16506f5ff46c610dc6 Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Sun, 24 May 2026 09:32:54 -0500 Subject: [PATCH] Audit code quality and deduplication opportunities --- docs/roadmap/audit.md | 591 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 591 insertions(+) create mode 100644 docs/roadmap/audit.md diff --git a/docs/roadmap/audit.md b/docs/roadmap/audit.md new file mode 100644 index 0000000..f5c55d8 --- /dev/null +++ b/docs/roadmap/audit.md @@ -0,0 +1,591 @@ +# Pre-1.0 Code Quality And Deduplication Audit + +## Executive Summary + +seriatim's current codebase is in good shape for a limited pre-1.0 cleanup pass. The main command paths are explicit, tests cover the public CLI and important transformation behavior, and the implemented architecture mostly matches the policy in `docs/policy/architecture.md`: merge uses a registry-driven pipeline, while trim and normalize operate at the artifact level. + +The top three refactoring targets before 1.0 are: + +1. Centralize public output schema names, schema validation selection, and artifact schema switching. +2. Reduce duplicated trim projection logic across full, intermediate, and minimal artifacts. +3. Move trim command orchestration out of `internal/cli` so CLI code remains a thin adapter like merge and normalize. + +No major architectural risk appears to block 1.0. The best next step is a series of small, behavior-preserving refactors protected by the existing CLI, trim, normalize, artifact, schema, and pipeline tests. + +## Repository Map Reviewed + +Reviewed documentation and policy: + +- `README.md` +- `docs/cli.md` +- `docs/config.md` +- `docs/operations.md` +- `docs/troubleshooting.md` +- `docs/policy/architecture.md` +- `docs/policy/development.md` +- `docs/internal/pipeline.md` +- `docs/internal/artifacts.md` +- `docs/internal/modules.md` +- `docs/integrations/output-schemas.md` +- `docs/integrations/whisperx-json.md` +- `docs/roadmap/documentation.md` + +Reviewed implementation areas: + +- `cmd/seriatim`: root process error handling. +- `internal/cli`: Cobra command setup and command-level tests for `merge`, `trim`, and `normalize`. +- `internal/config`: validated config construction, defaults, environment variables, path validation, and config tests. +- `internal/pipeline`: registry resolution, stage ordering, preprocessing state validation, and pipeline execution. +- `internal/builtin`: built-in input, preprocess, merge, postprocess, and output modules. +- `internal/artifact`: conversion from merged model to public output artifacts. +- `internal/trim`: selector parsing, artifact parsing/conversion, trimming, and trim tests. +- `internal/normalize`: artifact-level parsing, repair, building, reporting, and normalize tests. +- `internal/report`: report model and JSON writer. +- `internal/overlap`, `internal/coalesce`, `internal/danglers`, `internal/backchannel`, `internal/filler`, `internal/autocorrect`, `internal/speaker`: implemented modules and module-specific tests. +- `schema`: public Go schema types, embedded JSON Schemas, semantic validation, and schema tests. +- `examples` and `samples`: checked layout and role, not every sample payload line-by-line. + +The reviewed execution paths were: + +- `seriatim merge`: Cobra options, `config.NewMergeConfig`, `pipeline.Run`, built-in registry, output writer, optional report. +- `seriatim trim`: Cobra options, `config.NewTrimConfig`, artifact parsing, trim application, schema conversion, output writing, optional report. +- `seriatim normalize`: Cobra options, `config.NewNormalizeConfig`, `normalize.Run`, artifact parsing/building, output writing, optional report. + +No `internal/app`, `internal/stage`, `internal/modules`, `internal/validators`, `internal/adapters`, `internal/storage`, `internal/manifest`, `pkg`, or top-level `tests` directories exist in the current layout. Equivalent responsibilities are implemented in the packages listed above. + +## High-Confidence Deduplication Opportunities + +### Centralize Output Schema Names And Schema Selection + +Affected files/packages: + +- `internal/config` +- `internal/trim` +- `internal/artifact` +- `internal/normalize` +- `schema` + +Duplicated or near-duplicated behavior: + +- `internal/config` defines `seriatim-minimal`, `seriatim-intermediate`, and `seriatim-full` as output schema constants and validates CLI/config values. +- `internal/trim/artifact.go` defines another set of constants with the same string values. +- `internal/artifact`, `internal/normalize`, and `internal/trim` each switch over the same schema names to select conversion or validation behavior. + +Why it matters: + +- Output schema names are part of the public interface. If a schema name, default, or validation error changes in one package but not another, `merge`, `trim`, and `normalize` can drift. +- The current duplication is small but central enough that future schema changes would require edits in several packages. + +Recommended refactor: + +- Keep one canonical set of public schema names, preferably outside command-specific config construction. +- Expose narrow helpers for schema validation and display text where needed. +- Preserve the current semantic difference that `merge` and `normalize` resolve `SERIATIM_OUTPUT_SCHEMA` and default to intermediate, while `trim` preserves the input artifact schema unless `--output-schema` is supplied. +- Do not build a broad schema registry unless a new implemented schema makes the switch statements materially harder to maintain. + +Suggested tests: + +- `internal/config` tests for schema defaults, env precedence, invalid values, and trim override behavior. +- `internal/cli` tests for merge, trim, and normalize schema flags. +- `internal/artifact`, `internal/trim`, `internal/normalize`, and `schema` tests for selected shape validation. + +Risk level: Low to medium. Public behavior must stay byte-compatible where tests assert shapes and diagnostics. + +### Reduce Duplicated Trim Projection Logic Across Artifact Shapes + +Affected files/packages: + +- `internal/trim/apply.go` +- `internal/trim/apply_test.go` +- `internal/cli/trim_test.go` + +Duplicated or near-duplicated behavior: + +- `Apply`, `ApplyIntermediate`, and `ApplyMinimal` each validate mode, reject empty selectors, collect input IDs, validate sequential IDs, verify selected IDs exist, apply keep/remove policy, renumber retained segments from 1, build old-to-new mappings, collect removed IDs, and enforce `AllowEmpty`. +- Only the segment shape and full-schema overlap group recomputation differ. + +Why it matters: + +- Trim is user-facing artifact surgery. Drift in ID validation, empty-output handling, or keep/remove behavior across schemas would produce confusing public differences. +- The duplicated loops make future fixes to selector behavior or ID policy likely to require changes in three places. + +Recommended refactor: + +- Extract a small projection helper that operates on ordered segment IDs and returns retained indexes, old-to-new ID mapping, removed IDs, and empty-output validation. +- Keep schema-specific reconstruction local to each artifact shape. +- Keep full-schema overlap recomputation separate; it is a real semantic difference and should remain obvious. + +Suggested tests: + +- Existing `internal/trim/apply_test.go` coverage for keep/remove, renumbering, sequential ID validation, empty output, schema preservation, and overlap recomputation. +- Existing `internal/cli/trim_test.go` coverage for end-to-end artifact behavior and report audit fields. +- Add one table test that asserts the same selector policy across all three schemas. + +Risk level: Medium. The refactor touches public trim behavior, but the duplicated policy is well covered. + +### Move Trim Orchestration Out Of The CLI Adapter + +Affected files/packages: + +- `internal/cli/trim.go` +- `internal/trim` +- `internal/config` +- `internal/report` + +Duplicated or near-duplicated behavior: + +- `merge` parses flags, builds config, and delegates to `pipeline.Run`. +- `normalize` parses flags, builds config, and delegates to `normalize.Run`. +- `trim` parses flags and config, but also reads files, parses artifacts, applies domain logic, converts schemas, validates output, writes output JSON, builds audit payloads, and writes reports directly in `internal/cli`. + +Why it matters: + +- This is the clearest boundary drift from the architecture policy. CLI should stay an adapter for flag parsing and command dispatch. +- Keeping trim orchestration in CLI makes it harder to test trim as an application service without Cobra and makes report/output behavior easier to diverge from normalize. + +Recommended refactor: + +- Add a `trim.Run(ctx, cfg)` or similarly narrow artifact-level service in `internal/trim`. +- Move artifact reading, selector parsing, apply/convert/validate/write/report orchestration into that service. +- Leave Cobra flag definitions and `config.NewTrimConfig` calls in `internal/cli`. +- Keep trim audit fields stable unless tests and docs are intentionally updated. + +Suggested tests: + +- Keep existing `internal/cli/trim_test.go` end-to-end tests. +- Add direct `internal/trim` service tests for report generation and output schema conversion once the orchestration moves. + +Risk level: Medium. It is mostly a move, but report event wording and error wrapping must remain stable. + +### Centralize Pretty JSON File Writing + +Affected files/packages: + +- `internal/builtin/output.go` +- `internal/cli/trim.go` +- `internal/normalize/normalize.go` +- `internal/report/report.go` + +Duplicated or near-duplicated behavior: + +- Several packages create a file with `os.Create`, use `json.NewEncoder`, set a two-space indent, encode a value, and defer close. +- Error wrapping differs by call site: normalize wraps encode errors, trim and merge output mostly return raw errors, and report writing returns raw encode errors. + +Why it matters: + +- JSON artifacts and reports are core outputs. Formatting and write error semantics should not drift accidentally. +- Centralizing this low-level operation would simplify future changes such as consistent close error handling or atomic write policy, if such behavior is ever implemented. + +Recommended refactor: + +- Introduce a small internal helper for deterministic JSON file writing. +- Keep report construction in `internal/report`; only share the file-writing mechanics. +- Do not introduce atomic writes or temporary files as part of this cleanup unless that behavior is intentionally designed and documented. + +Suggested tests: + +- Existing CLI tests that read output JSON for all commands. +- Existing report tests through merge, trim, and normalize CLI paths. +- A small helper-level test can verify indentation and trailing newline if those become explicit guarantees. + +Risk level: Low. + +## Medium-Confidence Opportunities + +### Simplify Artifact Schema Switching In `internal/trim` + +Affected files/packages: + +- `internal/trim/artifact.go` +- `internal/trim/artifact_test.go` + +Duplicated or near-duplicated behavior: + +- `Artifact.Value`, `SegmentCount`, `Application`, `Version`, `ValidateArtifact`, `ApplyArtifact`, and `ConvertArtifact` all switch on the same schema discriminator and nil-check the same payload pointers. + +Why it matters: + +- The wrapper works, but the repeated switch boilerplate makes it easier to miss one accessor when adding a field or changing error behavior. + +Recommended refactor: + +- After centralizing schema names, consider small methods or private helpers that reduce repeated nil-check/access patterns. +- Avoid a generic visitor framework unless it directly removes the existing boilerplate without hiding schema-specific conversion rules. + +Suggested tests: + +- `internal/trim/artifact_test.go` +- `internal/cli/trim_test.go` schema conversion cases. + +Risk level: Low to medium. + +### Share Common Config Path Validation Helpers For Single-Input Commands + +Affected files/packages: + +- `internal/config/config.go` +- `internal/config/config_test.go` + +Duplicated or near-duplicated behavior: + +- `NewTrimConfig` and `NewNormalizeConfig` both trim, clean, require, and stat a single `--input-file`. +- They also share `--output-file` and optional `--report-file` normalization behavior. + +Why it matters: + +- Config validation is a public command contract. Even small drift in missing file errors, directory errors, or output path parent checks would be user-visible. + +Recommended refactor: + +- Add private helpers for required single input files and optional output/report paths. +- Keep merge's multi-input normalization separate because it deduplicates and sorts repeated `--input-file` values. +- Preserve the intentional output schema difference between trim and normalize. + +Suggested tests: + +- Existing `internal/config` tests for trim and normalize input/output/report errors. +- Existing CLI tests for report path failures. + +Risk level: Low. + +### Add Narrow CLI Flag Helper Functions + +Affected files/packages: + +- `internal/cli/merge.go` +- `internal/cli/trim.go` +- `internal/cli/normalize.go` + +Duplicated or near-duplicated behavior: + +- `--input-file`, `--output-file`, `--report-file`, `--output-schema`, and `--output-modules` are defined in multiple commands with related help text and defaults. + +Why it matters: + +- Flag names and help text are part of the user interface. Minor drift between commands can make docs and tests harder to keep accurate. + +Recommended refactor: + +- Add small flag registration helpers only for shared flags whose semantics are genuinely the same. +- Do not introduce a command factory; current command files are short and readable. +- Keep trim's `--output-schema` help/default distinct because omitted trim schema preserves the input artifact schema. + +Suggested tests: + +- Existing command recognition and behavior tests. +- Add help-output assertions only if the helper refactor changes how help text is generated. + +Risk level: Low. + +### Centralize Segment Provenance Reference Formatting Where Semantics Match + +Affected files/packages: + +- `internal/overlap` +- `internal/coalesce` +- `internal/danglers` +- `internal/model` + +Duplicated or near-duplicated behavior: + +- Several modules construct or interpret provenance references such as `source#index`, `word-run:group:speaker:run`, `coalesce:n`, and `resolve-danglers:n`. +- `internal/overlap` and `internal/coalesce` both prefer `Source` plus `SourceSegmentIndex` and fall back to `SourceRef`. + +Why it matters: + +- Provenance references appear in public full output and reports/tests rely on deterministic values. A formatting mismatch could affect downstream consumers. + +Recommended refactor: + +- Introduce a very small helper for the common `source#index` or "best available segment reference" behavior. +- Leave module-specific generated prefixes local unless another module needs to parse or construct them with the same semantics. + +Suggested tests: + +- `internal/overlap` resolve/detect tests. +- `internal/coalesce` tests. +- Merge CLI tests that assert `source_ref`, `derived_from`, and overlap group segment references. + +Risk level: Medium. Public full-output provenance must remain stable. + +### Share Category Tagging Mechanics Between Backchannel And Filler Carefully + +Affected files/packages: + +- `internal/backchannel` +- `internal/filler` +- `internal/builtin` + +Duplicated or near-duplicated behavior: + +- Backchannel and filler modules both normalize text by removing punctuation, collapse fields, reject empty text, enforce a maximum word count of three, enforce a max duration, match regex patterns, avoid duplicate categories, and append a category. + +Why it matters: + +- The policies are similar enough that a bug fix to normalization or duplicate category handling may need to be applied twice. + +Recommended refactor: + +- Consider a tiny private shared helper for tag application mechanics if another tagger is added or if a bug is found in the common logic. +- Keep the category names, regex lists, and duration defaults in their current packages. +- Do not create a broad classifier framework before 1.0. + +Suggested tests: + +- `internal/backchannel/backchannel_test.go` +- `internal/filler/filler_test.go` +- Merge CLI tests that assert category tagging and report events. + +Risk level: Low to medium. + +### Reduce Repetition In Schema Semantic Validation + +Affected files/packages: + +- `schema/output.go` +- `schema/output_test.go` + +Duplicated or near-duplicated behavior: + +- Full, intermediate, and minimal semantic validators each enforce sequential segment IDs and non-decreasing timing. +- Full validation also checks overlap group timing, which is intentionally schema-specific. + +Why it matters: + +- Sequential IDs and timing are cross-schema public invariants. Drift in error wording or strictness would be confusing. + +Recommended refactor: + +- Consider a small helper that validates ordered ID/timing pairs for all segment shapes. +- Keep full overlap group validation separate. + +Suggested tests: + +- Existing schema validation tests for missing/non-sequential IDs and invalid timing. +- Add cross-schema semantic validation cases if helper extraction touches all three shapes. + +Risk level: Low. + +## Boundary And Responsibility Concerns + +The main boundary concern is `internal/cli/trim.go`. It currently holds command parsing, artifact I/O, selector parsing, domain execution, schema conversion, output validation, output writing, report assembly, and audit sorting. That orchestration belongs in `internal/trim` under the current architecture because trim is an artifact-level application command, not CLI-specific behavior. + +`internal/normalize` already provides a better pattern: the CLI builds `config.NormalizeConfig` and delegates to `normalize.Run`. `merge` follows the same boundary direction by delegating to `pipeline.Run`. + +Other boundary observations: + +- YAML loading for speaker maps and autocorrect rules lives in narrow packages and is called from built-in modules. This is acceptable for current behavior, although future refactors could split file loading from pure transformation if tests start needing adapter-free module execution. +- `schema` owns public schema structs, embedded JSON Schema validation, and semantic validation. That is an appropriate boundary. Avoid moving command defaults or CLI wording into `schema`. +- `internal/report` owns report data structures and report JSON writing. It should not grow command-specific audit policy, but it can reasonably share low-level deterministic JSON writing. + +## Path, Key, And Naming Construction Review + +seriatim currently uses local filesystem paths only. There are no remote keys, cache paths, manifests, lock files, daemon paths, object-store keys, or resume state paths in the inspected implementation. + +Path validation is reasonably centralized in `internal/config`: + +- `normalizeInputFiles` handles merge's repeated input files, duplicate detection, sorting, and file existence. +- `normalizeOutputPath` validates output/report parent directories. +- `requireFile` validates input files and YAML config files. + +Cleanup opportunities: + +- Add private config helpers for required single input paths and optional report paths to reduce repeated trim/normalize validation. +- Centralize deterministic JSON output file writing as described above. +- Consider a small provenance reference helper for `source#index` formatting and fallback behavior where `internal/overlap` and `internal/coalesce` already share semantics. + +No remote key or generated workspace path cleanup is applicable. + +## Resolution And Catalog Review + +Module resolution is cleanly centralized for merge: + +- `internal/builtin.NewRegistry` registers built-in input, preprocessing, postprocessing, merger, and output modules. +- `internal/pipeline.Registry` resolves names and returns user-facing unknown module errors. +- `pipeline.Run` validates preprocessing state transitions before execution. + +Output module resolution differs by command: + +- Merge resolves output modules through the pipeline registry. +- Normalize accepts only `json` through config validation. +- Trim does not expose output modules and always writes JSON. + +Those differences appear intentional for current behavior. Do not force trim and normalize into the merge registry unless artifact-level commands gain actual pluggable output modules. + +Schema resolution is less centralized: + +- Config validates public schema names for CLI/config inputs. +- Artifact, normalize, and trim packages switch over the same schema values for output construction, parsing, conversion, and validation. + +Recommended centralization is limited to schema names and narrow validation/selection helpers. Avoid a plugin or catalog abstraction that would imply unimplemented dynamic schemas. + +## Config And Command-Loading Review + +Config loading is explicit and mostly consistent: + +- CLI commands parse flags into option structs. +- `internal/config` validates and normalizes runtime configs. +- Merge and normalize resolve `SERIATIM_OUTPUT_SCHEMA`; trim accepts an explicit schema override and otherwise preserves the input artifact schema. +- Merge sorts and deduplicates repeated input files; trim and normalize each require exactly one input file. + +Likely intentional differences: + +- Trim has `--keep`, `--remove`, and `--allow-empty`; merge and normalize do not. +- Merge exposes module lists and stage config; trim and normalize do not run the merge pipeline. +- Normalize validates output modules as only `json`; trim has no output module flag. +- `--output-schema` has a default in merge and normalize help, but trim's empty default is meaningful. + +Likely cleanup opportunities: + +- Share path/report validation helpers for single-input commands. +- Share flag registration for truly common flags after confirming help text stays stable. +- Add small config test builders to reduce repeated boilerplate in `internal/config/config_test.go`. + +No duplicated secret handling was found; no secrets are currently implemented. + +## State, Manifest, Or Progress Handling Review + +No durable state, manifests, checkpoints, progress files, resume logic, force mode, dry-run mode, remote storage, or daemon state are implemented. + +Reports are deterministic JSON event artifacts: + +- Merge reports are finalized in `internal/pipeline`. +- Normalize reports are built in `internal/normalize`. +- Trim reports are currently built in `internal/cli`. + +The only state/progress cleanup recommended before 1.0 is to align trim report construction with an `internal/trim` application service and to avoid adding manifest/resume abstractions unless a concrete implemented workflow requires them. + +## Refactors To Avoid Before 1.0 + +Avoid these tempting refactors before 1.0: + +- A generic workflow engine for merge, trim, and normalize. Their command semantics are different enough that a shared engine would obscure behavior. +- A broad plugin architecture. Current modules are built-in and registry-driven; dynamic plugins are not implemented. +- A sweeping CLI redesign or command factory. The current explicit Cobra setup is easy to audit. +- A generalized schema catalog that implies runtime-extensible schemas. Only the implemented minimal, intermediate, and full output schemas should be represented. +- A manifest, checkpoint, resume, or dry-run framework. No such state model exists today. +- Premature generics-heavy helpers for schema conversions. Keep helpers small and tied to duplicated policy, not shape similarity alone. +- Merging backchannel and filler into one classifier package unless the common mechanics are extracted narrowly and domain-specific rules remain obvious. +- Replacing all file I/O with an adapter layer. The current app is filesystem-only; introduce adapter seams only where they reduce tested duplication or clarify command boundaries. + +## Recommended Implementation Sequence + +1. Centralize schema names and output schema validation helpers. + - Goal: one canonical public schema name source and stable validation behavior. + - Files: `internal/config`, `internal/trim`, `internal/artifact`, `internal/normalize`, `schema` as needed. + - Tests: `go test ./internal/config ./internal/artifact ./internal/trim ./internal/normalize ./schema ./internal/cli`. + - Prompt size: one small implementation prompt. + +2. Extract trim projection policy. + - Goal: one implementation of keep/remove selection, sequential ID validation, renumbering, old-to-new mapping, removed IDs, and allow-empty policy. + - Files: `internal/trim/apply.go`, `internal/trim/apply_test.go`. + - Tests: `go test ./internal/trim ./internal/cli`. + - Prompt size: one prompt. + +3. Move trim orchestration into `internal/trim`. + - Goal: make trim CLI match the merge/normalize adapter boundary. + - Files: `internal/cli/trim.go`, new or updated `internal/trim` service file, trim tests. + - Tests: `go test ./internal/trim ./internal/cli`. + - Prompt size: one prompt. + +4. Centralize deterministic JSON output writing. + - Goal: remove repeated `os.Create` plus indented JSON encoder boilerplate. + - Files: a small internal helper plus `internal/builtin/output.go`, `internal/normalize/normalize.go`, `internal/trim` or `internal/cli/trim.go`, `internal/report/report.go`. + - Tests: `go test ./internal/builtin ./internal/normalize ./internal/trim ./internal/report ./internal/cli`. + - Prompt size: one prompt. + +5. Clean up config and CLI repetition. + - Goal: private helpers for single input path validation, optional report paths, and common flags where semantics match. + - Files: `internal/config/config.go`, `internal/config/config_test.go`, `internal/cli/*.go`. + - Tests: `go test ./internal/config ./internal/cli`. + - Prompt size: one prompt; split CLI helper work if help text assertions are added. + +6. Review provenance and category helper extraction. + - Goal: centralize only shared mechanics that are easy to get wrong. + - Files: `internal/overlap`, `internal/coalesce`, maybe `internal/model`; `internal/backchannel`, `internal/filler`. + - Tests: `go test ./internal/overlap ./internal/coalesce ./internal/backchannel ./internal/filler ./internal/cli`. + - Prompt size: one or two prompts depending on whether provenance and category work are both pursued. + +7. Test helper cleanup. + - Goal: reduce repeated config builders and CLI test fixtures without hiding test intent. + - Files: `internal/config/*_test.go`, `internal/cli/*_test.go`, selected module tests. + - Tests: affected package tests plus `go test ./...`. + - Prompt size: one prompt if scoped to config/CLI; otherwise split by package. + +8. Dead-code and legacy terminology sweep. + - Goal: remove stale helpers or wording left after cleanup. + - Files: code and docs touched by the above stages. + - Tests: `go test ./...`; grep for stale schema or architecture terms. + - Prompt size: one prompt. + +## Test Strategy + +Before refactoring: + +- Use existing tests as a behavior lock: + - `go test ./internal/config` + - `go test ./internal/trim` + - `go test ./internal/normalize` + - `go test ./internal/artifact` + - `go test ./schema` + - `go test ./internal/cli` + +During schema cleanup: + +- Preserve tests covering schema defaults, env precedence, invalid schema values, trim schema preservation, trim schema conversion, normalize selected schema, and merge output schemas. +- Add a small cross-command test only if centralization changes the public error text source. + +During trim projection cleanup: + +- Add or preserve tests that assert the same selector behavior for full, intermediate, and minimal inputs. +- Keep full-schema overlap group recomputation tests separate. + +During trim orchestration move: + +- Keep CLI end-to-end tests for trim output and reports. +- Add direct `internal/trim` service tests if report construction moves out of CLI. + +During JSON writer cleanup: + +- Preserve CLI tests that read generated JSON. +- If the helper claims deterministic formatting, add a focused helper test for indentation and newline behavior. + +During provenance/category cleanup: + +- Preserve module tests and merge CLI tests that assert `source_ref`, `derived_from`, overlap group segment refs, backchannel categories, filler categories, and report events. + +Final validation for any cleanup sequence: + +- `go test ./...` +- `go run ./cmd/seriatim --help` +- `go run ./cmd/seriatim merge --help` +- `go run ./cmd/seriatim trim --help` +- `go run ./cmd/seriatim normalize --help` + +For this audit-only pass, the full test suite was intentionally not run because no code or example behavior changed. + +## Appendix: Findings Not Worth Acting On + +### Keep Merge Pipeline Registry Explicit + +The registry resolution methods for input readers, preprocessors, postprocessors, output writers, and the merger look similar, but they produce stage-specific error messages and keep stage boundaries clear. A generic resolver would save little and could make errors less direct. + +### Keep Merge, Trim, And Normalize As Separate Command Concepts + +The commands share flags and file output behavior, but their domain semantics differ. Merge is a staged pipeline over raw inputs; trim and normalize operate on artifacts. A shared command runner would likely obscure those distinctions. + +### Do Not Centralize All File Reads + +`internal/builtin/input`, `internal/normalize/parse`, `internal/speaker`, `internal/autocorrect`, and trim orchestration read different file contracts and wrap errors differently. Centralizing all reads would not improve clarity today. + +### Keep Schema-Specific Artifact Conversion Visible + +Full, intermediate, and minimal outputs are intentionally different public contracts. Helpers can remove repeated accessors and schema names, but conversion code should remain easy to audit. + +### Leave `samples/` Alone In Code Cleanup + +`samples/` is a documentation/data hygiene question, not a code-quality refactor. The cleanup sequence should focus on maintained `examples/` and avoid destructive sample moves without a separate privacy and documentation pass. + +### Avoid Test Fixture Over-Abstraction + +There is repeated test setup in CLI and config tests, but much of it makes public behavior explicit at the call site. Add small builders where they reduce noise, but do not hide important command arguments behind opaque fixtures.