# 0.1.1 Release Validation

## Result

The v0.1.1 model-selection and local-directory changes passed the current 556-test source suite on Linux with Python 3.12. The underlying v0.1.0 release gate had passed 477 tests plus 6 subtests on Python 3.10 through 3.13. New CUDA runs covered the built wheel, default-model regression, alternate dense checkpoints, saved bitsandbytes INT8/INT4 checkpoints, PEFT LoRA adapters, and Hub/local source combinations.

No defect remained open from the completed v0.1.1 validation. Alternate checkpoints are supported execution paths, not certified accuracy-equivalent replacements.

Validation period: 2026-07-14 to 2026-07-15

Reference host:

```text
OS: Linux
Python: 3.12.12 for CUDA and installed-wheel tests
GPU: NVIDIA GeForce RTX 3060 12 GB
Driver: 535.309.01
Validated CUDA runtime: PyTorch 2.11.0+cu128
Transformers: 5.13.1
TorchCodec: 0.14.0+cpu
Librosa: 0.11.0
Numba: 0.66.0
NumPy: 2.4.6
Accelerate: 1.13.0 for saved quantized checkpoints
BitsAndBytes: 0.49.2 for saved quantized checkpoints
PEFT: 0.19.1 for LoRA adapters
```

## Inherited Runtime Baseline

The complete v0.1.0 CLI, Python API, decoder, VAD, alignment, filesystem, cancellation, and installed-distribution evidence remains in [0.1.0 Release Validation](0.1.0-release-validation.md). Those real hardware commands were not all repeated for v0.1.1. The current source suite re-exercised their behavioral contracts on Python 3.12, and the default-model 500-file package run below checked the inference path for regression.

v0.1.1 retains Transformers 5.13.1, the checked `uv.lock`, Librosa as a core feature-extraction dependency, automatic TorchCodec then FFmpeg decoding, and explicit-only Librosa decoding. `uv.lock` belongs to the source checkout and release tree, not the wheel or source distribution; pip users do not consume it.

## Model Checkpoint Validation

The CLI and Python API accept an alternate Hugging Face model repository or local model directory, plus an optional PEFT adapter repository or local adapter directory. Hub references may select a revision and are resolved to immutable commits before inference, checkpoint-state comparison, output rendering, and profile publication. Local directories are canonicalized and loaded directly; revisions are rejected because they have no meaning for a filesystem source. The processor and configuration must remain native Cohere ASR implementations with remote code disabled.

Three loading paths are supported:

| Loading path | Runtime contract | Optional installation |
|---|---|---|
| Native dense checkpoint | `CohereAsrConfig`, `CohereAsrProcessor`, and `CohereAsrForConditionalGeneration`; Hub or local directory | Core package |
| Saved BitsAndBytes INT8 or INT4 | Quantization metadata in `config.json`, CUDA placement through Accelerate, and no post-load `.to()` | `cohere-transcribe[quantized]` |
| PEFT LoRA adapter | `SEQ_2_SEQ_LM`; Hub-backed bases require repository and optional revision agreement, while local bases use structural PEFT loading; read-only load, `safe_merge`, wrapper removal, then the normal Cohere hot path | `cohere-transcribe[adapters]` |

Other quantizers, ambiguous INT4/INT8 metadata, quantized CPU or MPS execution, adapters over saved quantized bases, remote-code architectures, ONNX ASR, GGUF, and MLX are rejected explicitly rather than being loaded through an unvalidated path. Live metadata resolution rejected the ONNX-only `Masterx/cohere-transcribe-arabic-07-2026-ONNX` repository before input planning, while the default, saved INT8, and public LoRA repositories retained their exact resolved identities. The quantized doctor passed with CUDA and returned status 1 when the same device was hidden.

Real package-path checks completed for two alternate dense checkpoints, saved INT8 through the CLI, saved INT4 through a recursive two-file Python API call, and a four-file PEFT CLI run. They covered segment TXT/JSON/profile output, nested publication, checkpoint state, immutable provenance, and verified skip reuse. Doctor checks resolved and validated dense, INT8, and adapter selections without loading their weights.

The unchanged default model was rerun through the complete package over the retained 500-file workload. It completed 500/500 files in 39.16 seconds externally and 38.153 seconds in the profile, using 729 processor rows, 33 batches, and 21,587 generated tokens. Every TXT file was byte-identical to the retained output; the 39.16-second observation also matches the established 39.27-second installed-wheel median.

### Balanced Model Probe

The accuracy probe contains 500 complete clips: 100 each from Casablanca, Common Voice 18 Arabic, FLEURS `ar_eg`, a Quran Classical Arabic proxy, and SADA22. Its manifest reports 5,032.699 seconds. Timings cover a warm model, complete-clip decoding, feature extraction, generation, and text decoding. They exclude model load, VAD, alignment, and output publication. WER and CER use the same lexical normalization for every checkpoint; combining marks are removed, so this is not a diacritization-quality measurement.

| Checkpoint, BF16 unless noted | Batch | Wall | RTFx | Peak CUDA | WER | CER |
|---|---:|---:|---:|---:|---:|---:|
| Default dense | 24 | 32.46s | 155.04x | 9.426 GiB | 22.955% | 11.581% |
| NAMAA saved INT8 | 24 | 70.67s | 71.21x | 7.761 GiB | 22.955% | 11.578% |
| NAMAA saved INT4 | 24 | 43.66s | 115.27x | 6.950 GiB | 22.986% | 11.344% |
| NAMAA Tashkeel dense | 24 | 41.53s | 121.20x | 9.426 GiB | 29.272% | 14.121% |
| oddadmix dialectal dense | 24 | 37.33s | 134.82x | 9.426 GiB | 49.620% | 36.686% |
| oddadmix dialectal dense | 1 | 119.02s | 42.29x | 4.392 GiB | 50.753% | 37.446% |

INT8 changed 43 of 500 hypotheses relative to BF16, with 1.605% transcript-divergence WER. Its lexical WER delta was 0.000 percentage points, with a paired 95% interval of -0.404 to +0.376 points. INT4 changed 140 hypotheses, with 5.879% transcript-divergence WER; its lexical WER delta was +0.031 points, with a paired interval of -0.909 to +0.977 points. These saved checkpoints are memory options on the RTX 3060, not speed options: INT8 was 2.18 times slower and reduced peak allocation by 17.7%, while INT4 was 1.35 times slower and reduced it by 26.3% at batch 24.

The Tashkeel checkpoint improved the Quran proxy from 13.848% to 9.329% WER but regressed the other four subsets under lexical scoring. Its intended diacritization behavior requires a separate diacritic-aware reference set. The dialectal checkpoint's private-domain model-card result did not generalize to this independent mixed probe: batch 24 was +26.665 WER points versus the default, and batch 1 was 3.19 times slower than batch 24 without an accuracy improvement. Batch size remains an explicit user choice instead of a checkpoint-specific hidden policy.

### Adapter Probe

The public `amzilmustapha/cohere-darija-lora-10-7-26` adapter was evaluated on 100 independent Casablanca clips totaling 364.718 seconds.

| Runtime | Wall | Generation | Peak CUDA | WER | CER |
|---|---:|---:|---:|---:|---:|
| Dense base | 3.51s | 2.63s | 4.638 GiB | 53.355% | 16.477% |
| Safely merged adapter | 13.15s | 12.34s | 4.638 GiB | 289.853% | 315.204% |
| Unmerged adapter control | 23.81s | 22.93s | 4.761 GiB | 303.764% | 316.274% |

The adapter is mechanically compatible but failed this independent accuracy gate because it generated pathological repetitions on many clips. This is a result for that adapter, not a general claim about LoRA. Safe merging restored the dense model's peak allocation and reduced generation time by 46.2% relative to the unmerged control, so the package keeps the validated merge path while documenting that every adapter still needs its own quality gate.

### Five-Reviewer Model-Selection Audit

Five independent reviews covered model identity and compatibility, inference and resource lifetime, CLI/API behavior, state and publication contracts, packaging, tests, and documentation. Changes were accepted only when at least two reviews identified the same issue.

| Consensus finding | Review agreement | Resolution |
|---|---:|---|
| Hugging Face cache parsing selected the first `snapshots` ancestor | 3/5 | Select the innermost valid 40-character snapshot commit and cover an unrelated ancestor in tests |
| Doctor could report an optional import failure and then report the same runtime as usable | 3/5 | Gate version success on successful imports; a missing PyTorch runtime also fails quantized CUDA validation without a secondary import |
| Doctor model and adapter selection flags were ignored without `--model-access` | 2/5 | Any non-default model, revision, adapter, or adapter revision now implies model-access validation |
| Alternate-model provenance lacked one integrated API/output/profile assertion | 3/5 | Add a public API publication test carrying an immutable adapter identity through the job, returned provenance, JSON, and profile |
| Documentation implied that checkpoint payloads expose model identity | 2/5 | Clarify that outputs and profiles expose identity while opaque checkpoint and cache contracts bind it |
| Checkpoint-only rendering unnecessarily required quantized or adapter runtimes | 2/5 | Split metadata resolution from weight verification; only fresh ASR verifies weights or requires Transformers, bitsandbytes, Accelerate, PEFT, VAD, and decoding dependencies needed by that path |
| Checkpoint-only jobs depended on model weight artifacts remaining cached | 2/5 | Defer supported-weight verification until input and checkpoint planning establishes that fresh ASR is required |

Single-review suggestions were not changed without independent support. They remain explicit review notes rather than confirmed defects: accepting nonstandard top-level quantization metadata, binding optional runtime versions into durable transcript contracts, rejecting redundant bitsandbytes alias fields beyond their resolved meaning, changing private-repository access wording, and adding a pre-Ampere policy for checkpoints saved with BF16 compute metadata.

The initial model-selection audit suite passed 522 tests and 6 subtests on Python 3.12.12. Ruff formatting and lint, the strict public API type check, lock validation, and bytecode compilation passed. A real saved-INT4 plus FP16 word-alignment run completed from the source package CLI in 15.63 seconds external wall time on an 8-second fixture; the rebuilt 0.1.1 wheel repeated it in 14.69 seconds. Both produced 23 aligned words and 4 cues with no fallback, one 53-token ASR row, no OOM or truncation retry, and exact INT4 repository, commit, format, and quantization provenance in output schema 8 and profile schema 9.

### Local Model and Adapter Directories

Local sources use the same validated model-format and adapter-compatibility paths as Hub sources. A string is interpreted as local when it resolves to an existing directory or is explicitly path-shaped; other strings remain eligible Hugging Face repository IDs. A Python `Path` or other `PathLike` always means a local directory and must already exist. Local paths are canonicalized before resource caching, checkpoint matching, result provenance, JSON output, and profile publication. The package does not copy, hash, upload, download, or create a second cache entry for a local model. Mutating model files in place while a reusable `Transcriber` is open is unsupported.

The source package was exercised offline against real local snapshots of the default dense model, the NAMAA INT8 and INT4 checkpoints, the NAMAA Tashkeel dense checkpoint, and the public Darija LoRA adapter. Dense, INT8, INT4, and INT4 plus FP16 word alignment all completed from direct local paths on the RTX 3060. The dense eight-second smoke produced 23 words in 5.853 seconds of profiled end-to-end time, used one 50-token row, peaked at 3.872 GiB allocated CUDA memory, and published the canonical local path with a null revision. The rebuilt wheel repeated that transcript exactly in offline mode in 5.893 profiled seconds, and its installed `cohere-transcribe-doctor` passed local model access. The INT4 word run produced 23 aligned words and 4 cues without fallback.

All four supported adapter-source combinations completed: local base with local adapter, Hub base with local adapter, local base with Hub adapter, and Hub base with Hub adapter. Their transcripts had the same SHA-256 value, `efd99990fa81a7fcfa876b8bc050caf2f730d979cf1d5e6fb287bc15fae6482e`. Hub bases still enforce the adapter's declared base repository and optional base revision. A local base skips that historical repository-string comparison and relies on PEFT's structural load and safe merge validation.

A five-file local dense batch completed in one generation batch. A reusable local-path `Transcriber` loaded the model in 3.059 seconds on its first call and reused it in 0.000014 seconds on the second resource acquisition. Relative paths and symlink aliases converge on the same canonical identity, and verified `--existing skip` work avoids loading the model. Negative checks cover local revisions, adapter revisions, nonexistent explicit paths, nonexistent `PathLike` inputs, existing files, malformed tilde expansion, incomplete weight directories, invalid JSON, unsupported configurations, and quantized CPU execution.

Five independent reviewers then audited the complete local-source change. The same acceptance rule applied: implementation changes required agreement from at least two reviewers.

| Consensus finding | Review agreement | Resolution |
|---|---:|---|
| Converting API `PathLike` values to strings could lose explicit local intent | 2/5 | Preserve `PathLike` as a local-only contract and reject missing local directories before Hub resolution |
| Malformed tilde paths could raise `RuntimeError` outside typed CLI/API errors | 2/5 | Convert filesystem and expansion failures to concise `ValueError` diagnostics |
| Documentation overstated quantization details exposed by Python result provenance | 3/5 | Limit that claim to JSON, profile, and state contracts; Python provenance exposes resolved identity and format |

Single-review suggestions were not changed without independent support: adding optional-extra runtime jobs to CI, changing one doctor help sentence, and adding a second redundant static-typing fixture for adapter `Path` values. The final local-source suite passed 556 tests on Python 3.12.12, followed by Ruff formatting and lint, strict public API Mypy, lock validation, and bytecode compilation.


## Current Automated Gates

| Gate | Result |
|---|---|
| Main CLI inventory | All 54 long-option forms and the `-h` alias accounted for |
| Doctor CLI inventory | All 8 long-option forms and the `-h` alias accounted for |
| Current source suite | 556 tests and 6 subtests passed on Python 3.12 |
| Earlier version matrix | 477 tests and 6 subtests passed on each of Python 3.10 through 3.13 before the v0.1.1 model-selection changes |
| Model execution | Default dense, alternate dense, saved INT8/INT4, and safely merged PEFT LoRA CUDA paths passed |
| Source resolution | Hub and local model/adapter combinations, canonical paths, immutable Hub revisions, and invalid combinations passed |
| Default-model regression | 500/500 retained transcripts matched, with established processor-row, batch, and token counts |
| Package quality | Ruff formatting and lint, strict public API Mypy, lock validation, and bytecode compilation passed |
| Distribution | Wheel and source distribution built; strict Twine metadata validation and installed-wheel API/CLI smokes passed |

The source suite covers CLI/API option parity, lazy imports, input ordering and recursion, partial failures, progress and cancellation, reusable lifetime, state invalidation, output containment and locking, publication, schemas, model identity, format and artifact validation, checkpoint-only dependency isolation, quantized diagnostics, OOM recovery, and provenance.

## Installed Distribution

The distribution is `cohere-transcribe`, the import package is `cohere_transcribe`, and the console commands are `cohere-transcribe` and `cohere-transcribe-doctor`. The checked lockfile resolves the same root distribution. The built artifacts are `cohere_transcribe-0.1.1-py3-none-any.whl` and `cohere_transcribe-0.1.1.tar.gz`; their metadata, wheel contents, entry points, and strict Twine validation passed.

A fresh Python 3.12 CPU environment installed the wheel with all 58 resolved dependencies, for 59 installed packages total. Dependency validation, the public import and typing marker, both console help paths, version reporting, and the segment-mode doctor passed. The doctor emitted only the expected CPU and uninstalled optional-feature warnings.

The same wheel was installed over the validated PyTorch 2.11.0+cu128 environment and transcribed the retained eight-second Arabic fixture with offline model resolution. It produced 23 words, 2 segment-timed cues, 1 processor row, 1 generation batch, and 50 generated tokens at 3.87 GiB peak CUDA allocation. Output JSON, profile model provenance, and the profile environment reported `cohere-transcribe` version `0.1.1`. The installed wheel also passed local dense and local INT4 word-alignment checks.

## Coverage Limits

The following paths were not certified by this Linux RTX 3060 validation:

- Apple MPS, Windows, or AMD ROCm execution.
- Multi-GPU scheduling; v0.1.1 selects one device.
- Saved bitsandbytes execution on CPU, MPS, ROCm, or a multi-GPU device map.
- PEFT adapter types other than LoRA or task types other than `SEQ_2_SEQ_LM`.
- A real CUDA GPU without BF16 support.
- Full 2B-model CPU throughput or CUDA FP32 ASR on 12 GB VRAM.
- Deliberately induced real CUDA OOM, device-side assertion, driver failure, disk exhaustion, fsync failure, or cryptographic lock-range collision.
- The one-hour FFmpeg timeout.
- ONNX CUDA VAD; the tested ONNX provider was CPU.
- Multi-host publication to shared storage; output locks coordinate processes for the same OS user on one host.

These are unvalidated environments or destructive fault injections, not known failures. Deterministic decision and cleanup branches have automated tests where practical.

## Release Assessment

On the dated reference host, v0.1.1 preserved the tested default-model transcripts and work counts and added validated Hub/local dense, saved bitsandbytes INT8/INT4, and safely merged PEFT LoRA paths. The current 556-test suite, code-quality gates, distribution build, clean installation, installed-wheel checks, and real CUDA probes passed. The earlier Python-version matrix applies to the v0.1.0 baseline; the complete v0.1.1 source suite was run on Python 3.12.

No unresolved functional defect was identified in this dated, environment-scoped validation. The coverage limits are listed above.
