# Limbu-First OCR Pipeline Updated: 2026-06-22 ## Goal Build the operational OCR path for Limbu pages before expanding the claim: imperfect still-page captures should be cleaned and parsed through a pipeline that can handle both Devanagari-written Limbu and Sirijonga-script Limbu, preserve line provenance, route or flag script-specific recognition risk, and emit review/audit artifacts for every page. The product boundary is a robust two-script Limbu OCR pipeline; any moving-camera workflow must first provide still page images to this pipeline and is not a separate video-to-page objective. This is a production digitization goal, not a CER claim by itself; claim-grade accuracy still requires frozen references and `run_page_ocr_eval.py`. One-line objective prompt: > Build a best-in-class, claim-audited Limbu OCR pipeline for real page images that understands both Devanagari-written Limbu and Sirijonga-script Limbu, with script-aware detection/recognition, page cleanup, language-specific correction, confidence review queues, and frozen page-level eval before any quality claim. ## Current Entry Point Check that the packaged mixed-script router can run on the machine: ```bash uv run ocrtech preflight-limbu-pipeline \ --model-config outputs/limbu-first-router-v1/model-card.json \ --out outputs/limbu-first-router-v1/runtime-preflight ``` For operational two-script readiness, use the stricter component-admission gate: ```bash uv run ocrtech preflight-limbu-pipeline \ --model-config outputs/limbu-first-router-v1/model-card.json \ --out outputs/limbu-first-router-v1/runtime-preflight-strict \ --require-validated-components \ --required-component-role devanagari_primary \ --required-component-role sirijonga_secondary ``` The loose preflight only answers whether the runtime and model-card wiring are usable. The strict preflight is the one that must pass before calling the mixed-script router ready: both the Devanagari primary and Sirijonga secondary must be recorded in `provenance.component_admission` with `validated` or `admitted` status. The JSON and Markdown reports record the enforced policy, including required Tesseract languages, strict component mode, and required component roles; malformed component-admission entries fail instead of disappearing from the audit. Preserve and normalize the capture first: ```bash uv run ocrtech prepare-limbu-capture path/to/raw-page.jpg --out outputs/limbu-page-prep \ --auto-detect-page \ --auto-deskew \ --rotate-degrees -1.5 \ --crop-box 40,80,1900,2840 ``` For difficult pages, manual corners can still override automatic detection: ```bash uv run ocrtech prepare-limbu-capture path/to/raw-page.jpg --out outputs/limbu-page-prep \ --crop-box 40,80,1900,2840 \ --perspective-quad 30,40,1780,20,1810,2600,60,2630 \ --auto-deskew ``` Audit the prepared capture bundle before OCR: ```bash uv run ocrtech audit-limbu-capture outputs/limbu-page-prep \ --require-metadata-path-self ``` For multi-page books or a batch of still frames, put the page images in a directory and run the book OCR runner directly. It scans supported image files in natural filename order, generates the raw page manifest with image hashes, prepares every page, writes the prepared OCR manifest, parses the book in preserve-line mode, writes aggregate editable text and review queues, and runs the book artifact audit. This is the default operator command for real photographed pages: ```bash PYTHONPATH=src /tmp/ocrtech-paddle311/bin/python tools/run_limbu_book_ocr.py \ --image-dir path/to/page-images \ --out outputs/limbu-book-ocr-run \ --page-id-prefix limbu-book-p \ --auto-deskew \ --max-auto-deskew-degrees 8 \ --min-prepared-width 1000 \ --min-prepared-height 1000 \ --min-prepared-entropy 0.5 \ --min-prepared-luminance-stddev 1.0 \ --min-prepared-edge-stddev 1.0 ``` If the folder contains non-target pages, covers, duplicate captures, or an exported source pack with mixed language candidates, filter it before OCR: ```bash PYTHONPATH=src /tmp/ocrtech-paddle311/bin/python tools/run_limbu_book_ocr.py \ --image-dir path/to/page-images \ --out outputs/limbu-book-ocr-run \ --page-id-prefix limbu-book-p \ --include-filename-regex '.*-01\.png$' \ --skip-duplicate-images \ --auto-deskew ``` `--include-filename-regex` keeps only filenames matching the regex, `--exclude-filename-regex` drops known non-target filenames, and `--skip-duplicate-images` skips later files with the same SHA-256 content as an earlier kept image. The generated manifest summary records discovered, skipped, duplicate, and kept images so a mixed folder cannot silently masquerade as a clean Limbu book. The manifest builder and runner also emit source attention flags: `source_images_skipped`, `duplicate_source_images_removed`, or `duplicate_source_images_present`. The key outputs are: - `raw-page-manifest/book-pages.jsonl`: generated page manifest with source image hashes. - `capture-prep/prepared-page-manifest.jsonl`: prepared-image manifest with bound capture metadata. - `capture-prep/capture-prep-dashboard.html`: raw/prepared page contact sheet for checking crop, deskew, perspective, and prepared-image quality before OCR review. - `book-ocr/book.md` and `book-ocr/book.body.md`: editable full/body book text. - `book-ocr/book-line-review-queue.tsv`: review sheet for weak or unresolved lines, including source crop paths and SHA-256s. - `book-ocr/book-review-dashboard.html`: crop-linked contact sheet for the book-line review queue. - `layout-gap-review/layout-gap-review-queue.tsv`: crop-linked review rows for suspicious vertical gaps between detected text rows, including a full-page context image path/hash with the gap band highlighted. - `layout-gap-review/layout-gap-review-dashboard.html`: contact sheet for the suspicious gap crop bands and their page context. - `limbu-book-ocr-run.json`: run summary with counts, hashes, audit result, per-page line/script/review counts, and operator attention flags. - `README.md`: operator summary, including source image discovery/skip/duplicate counts when `--image-dir` is used. Source attention flags are ingestion triage signals. `duplicate_source_images_present` means the run kept duplicate image content and should not be treated as a clean book batch until the manifest is filtered or rerun with `--skip-duplicate-images`. Operator attention flags are triage signals, not quality metrics. They mark pages with zero detected lines, all or many lines in review, high `other` script share, suspicious line-geometry gaps (`possible_missed_line_gap`), unavailable line geometry, or failed page artifact audit so the next human action is obvious: inspect the page, reshoot or recrop if needed, then work through the crop-bound review queue. The geometry-gap flag is computed from final `document.json` line boxes and catches unusually large vertical holes between detected rows even when confidence/script counts otherwise look healthy; structural page-marker footers are ignored so ordinary bottom page numbers do not trip the warning. Each suspicious gap also gets a crop-bound pending row in `layout-gap-review/layout-gap-review-queue.tsv`, so an operator can inspect the actual page band and the highlighted full-page context before deciding whether a missing line needs to be inserted. If page order needs manual correction or a page needs per-page crop/perspective settings, build or edit the raw manifest first. Each row needs `page_id` and `image_path`; optional per-page `capture_kwargs` can override rotation, crop, perspective, and deskew settings for difficult pages. ```bash uv run python tools/build_limbu_book_page_manifest.py \ --image-dir path/to/page-images \ --out outputs/limbu-book-pages.jsonl \ --page-id-prefix limbu-book-p \ --include-filename-regex '.*-01\.png$' \ --skip-duplicate-images ``` Then run the same OCR runner on that manifest: ```bash PYTHONPATH=src /tmp/ocrtech-paddle311/bin/python tools/run_limbu_book_ocr.py \ --page-manifest outputs/limbu-book-pages.jsonl \ --out outputs/limbu-book-ocr-run \ --auto-deskew ``` The lower-level capture/parse split is still available for debugging. First prepare the raw manifest: ```bash uv run python tools/prepare_limbu_book_captures.py \ --page-manifest path/to/raw-book-pages.jsonl \ --out outputs/limbu-book-capture-prep \ --auto-deskew \ --max-auto-deskew-degrees 8 ``` Then run the book parser on the generated manifest. Preserve detected lines, bind capture provenance, and send weak rows to review instead of deleting them with confidence filters: ```bash PYTHONPATH=src /tmp/ocrtech-paddle311/bin/python tools/parse_limbu_book_pages.py \ --page-manifest outputs/limbu-book-capture-prep/prepared-page-manifest.jsonl \ --out outputs/limbu-book-ocr-preserve \ --engine candidate \ --model-config outputs/limbu-router-v4-ppocr-devanagari-sirijonga-confidence-guard-2026-06-22/model-card.json ``` Then run `parse-limbu-doc` on the prepared image: ```bash uv run ocrtech parse-limbu-doc outputs/limbu-page-prep/prepared/raw-page.prepared.png \ --out outputs/limbu-page-run \ --engine candidate \ --model-config outputs/limbu-first-router-v1/model-card.json \ --capture-prep-metadata outputs/limbu-page-prep/limbu-capture-prep.json \ --post-correction-profile path/to/limbu-post-correction-profile.json \ --low-confidence-threshold 0.80 \ --sirijonga-low-confidence-threshold 0.85 \ --devanagari-low-confidence-threshold 0.80 \ --script-ratio-threshold 0.20 ``` When `--capture-prep-metadata` is supplied, `parse-limbu-doc` reruns the capture audit into `capture-prep-audit/`, fails if the prepared/raw bundle is stale or incomplete, and fails if the OCR input path does not match the audited `prepared_image_path`. Later, `audit-limbu-output` reruns that capture audit from the embedded metadata path into `capture-prep-replay-audit/`, so a prepared image tampered after OCR cannot keep passing on the stale bundled audit. Strict output audits can also pass prepared-image quality thresholds through to that replay with `--min-capture-prepared-width`, `--min-capture-prepared-height`, `--min-capture-prepared-entropy`, `--min-capture-prepared-luminance-stddev`, and `--min-capture-prepared-edge-stddev`, plus `--require-capture-metadata-path-self` when the final OCR output audit must enforce the same metadata self-binding as the capture audit. Use `audit-limbu-capture --require-metadata-path-self` for claim-grade capture bundles so the recorded `metadata_path` must resolve to the exact `limbu-capture-prep.json` being audited, instead of merely warning after a copied or renamed metadata file. Audit the OCR output bundle before review or eval: ```bash uv run ocrtech audit-limbu-output outputs/limbu-page-run ``` Audit any automatic correction profile before using it: ```bash uv run ocrtech audit-limbu-post-correction-profile \ path/to/limbu-post-correction-profile.json \ --out outputs/limbu-post-correction-profile-audit ``` For dry runs with sidecar OCR fixtures: ```bash uv run ocrtech parse-limbu-doc path/to/page.png --out outputs/limbu-sidecar-smoke --engine sidecar ``` For book-shaped runs, put the page images in reading order in a JSONL manifest and run the multi-page wrapper: ```jsonl {"page_id":"book-p001","image_path":"pages/page-001.png","parse_kwargs":{"line_detection_mode":"image-line"}} {"page_id":"book-p002","image_path":"pages/page-002.png","parse_kwargs":{"line_detection_mode":"image-line"}} ``` ```bash uv run python tools/parse_limbu_book_pages.py \ --page-manifest path/to/book-pages.jsonl \ --out outputs/limbu-book-run \ --engine candidate \ --model-config outputs/limbu-first-router-v1/model-card.json ``` The wrapper is intentionally thin: each page still goes through `parse-limbu-doc` / `parse_limbu_document`, and the book layer only aggregates per-page bundles into `book.md`, `book.body.md`, `book-review-queue.tsv`, `book-run.json`, and a `score-documents/` projection compatible with `tools/run_page_ocr_eval.py`. Manifest rows must provide `page_id` or `sample_id` or `id`, plus `image_path` or `source_path`; the optional `parse_kwargs` object is restricted to known page-parser settings so a book run cannot smuggle in unsupported behavior. Use this for multi-page digitization, then score with frozen references before making any quality claim. For the current Devanagari Limbu book path, add `--line-assembly` to produce the measured source-break line-structure projection: ```bash uv run python tools/parse_limbu_book_pages.py \ --page-manifest path/to/book-pages.jsonl \ --out outputs/limbu-book-run \ --engine candidate \ --model-config outputs/limbu-first-router-v1/model-card.json \ --line-assembly ``` This does not rewrite the audited per-page OCR bundles. It writes separate `line-assembly-source-documents/` and `line-assembled-documents/` directories, audits the assembled documents by replay, and points `book.md`, `book.body.md`, and `score-documents/` at that book-level projection. It also writes `book-line-review-queue.tsv`, which is the review sheet to use when checking assembled book text: each row names the editable book line, whether it was assembled, the source line ids, the source review rows that triggered review, and the assembled text with internal newlines escaped as `\n`. Keep `book-review-queue.tsv` as the source-page correction input for existing review-application tooling. After editing `book-line-review-queue.tsv`, apply accepted book-line corrections to a new editable projection: ```bash uv run python tools/apply_limbu_book_line_reviews.py \ outputs/limbu-book-run \ --out outputs/limbu-book-run-corrected ``` Accepted rows are statuses such as `accepted`, `corrected`, `verified`, or `done` with non-empty `corrected_text`. The tool writes corrected `book.md`, `book.body.md`, `book-documents/`, `score-documents/`, `book-line-correction-audit.json`, and `book-line-correction-pairs.jsonl`. It applies corrections to the assembled book-line projection and records source line ids. For current review queues, actionable rows must also keep valid `source_crop_paths` and `source_crop_sha256s`; stale or tampered crop references are rejected before any corrected book projection is written. It does not try to split an assembled-line correction back into the original page OCR fragments. If both `book-line-review-queue.tsv` and `layout-gap-review/layout-gap-review-queue.tsv` have been reviewed, apply both in the correct order with one command: ```bash uv run python tools/apply_limbu_book_review_queues.py \ outputs/limbu-book-run \ --out outputs/limbu-book-run-reviewed ``` The wrapper applies book-line corrections first, then accepted layout-gap insertions, and writes the final reviewed projection under `final-book/`. It records the source hashes, intermediate application reports, the final `book-run.json`, and a layout-gap application consistency audit. It also writes a top-level `README.md` pointing at the final editable text, final `book-run.json`, and consistency audit. This is the preferred operator command once both review queues have been edited. After editing `layout-gap-review/layout-gap-review-queue.tsv`, apply accepted missed-line insertions to a new editable projection: ```bash uv run python tools/apply_limbu_book_layout_gap_reviews.py \ outputs/limbu-book-run \ --out outputs/limbu-book-run-gap-corrected ``` Accepted layout-gap rows require an accepted/corrected/verified-style status, non-empty `corrected_text`, and valid `crop_path` / `crop_sha256`. The applicator inserts a new reviewed line at the gap geometry, writes chainable corrected `book.md`, `book.body.md`, `book-documents/`, `score-documents/`, `book-run.json`, and `layout-gap-review-application-audit.json`, and rejects stale or tampered crop hashes before writing the corrected projection. Audit the layout-gap application output: ```bash uv run python tools/audit_limbu_book_layout_gap_review_application.py \ outputs/limbu-book-run-gap-corrected ``` Audit the whole book bundle after the run: ```bash uv run python tools/audit_limbu_book_output.py outputs/limbu-book-run ``` This writes `limbu-book-output-audit.json` and `.md` for the raw OCR book bundle. It checks the book manifest, aggregate markdown, both review queues, score-document projection, per-page output audits, and line-assembly replay audit when assembly is enabled. It is an artifact consistency audit, not an OCR-quality claim. To replay already-materialized page OCR documents through the book wrapper, prepare sidecar inputs first: ```bash uv run python tools/prepare_limbu_book_sidecar_replay.py \ --eval-manifest path/to/eval.jsonl \ --documents-dir path/to/page-document-outputs \ --out outputs/limbu-book-replay-inputs ``` This is useful for verifying book packaging and scorer compatibility against selected diagnostic outputs. It is not fresh OCR inference; the replay summary records the source document hashes. After review, apply accepted corrections back to the parsed document: ```bash uv run ocrtech apply-limbu-review-corrections \ --document outputs/limbu-page-run/document.json \ --review-queue outputs/limbu-page-run/limbu-review-queue.tsv \ --out outputs/limbu-page-corrected ``` Freeze accepted correction pairs into deterministic train/heldout material before deriving or admitting a profile: ```bash uv run ocrtech build-limbu-correction-pair-pack \ outputs/limbu-page-corrected/limbu-correction-pairs.jsonl \ --out outputs/limbu-correction-pair-pack-v1 \ --pack-id limbu-corrections-v1 \ --heldout-fraction 0.20 ``` Correction-pair rows are script-class constrained before they can become training or held-out scoring substrate. Accepted review rows, pack building, pack audit, profile derivation, and held-out scoring all reject unsupported `script_class` values outside `limbu_sirijonga`, `devanagari_limbu`, `mixed_limbu_devanagari`, or `other`. Missing row values are inferred from the clean text; misspelled explicit values are not silently normalized. Audit the frozen correction-pair pack before deriving or scoring from it: ```bash uv run ocrtech audit-limbu-correction-pair-pack \ outputs/limbu-correction-pair-pack-v1 \ --out outputs/limbu-correction-pair-pack-v1/audit ``` The train split can seed an experimental deterministic profile: ```bash uv run ocrtech derive-limbu-post-correction-profile \ outputs/limbu-correction-pair-pack-v1/train-limbu-correction-pairs.jsonl \ --out outputs/limbu-post-correction-profile-derived \ --profile-id limbu-derived-post-correction-profile-v1 \ --min-support 2 ``` Score the profile on a separate held-out correction-pair pack before claiming validated automatic correction: ```bash uv run ocrtech score-limbu-post-correction-profile \ outputs/limbu-post-correction-profile-derived/limbu-post-correction-profile.json \ outputs/limbu-correction-pair-pack-v1/heldout-limbu-correction-pairs.jsonl \ --out outputs/limbu-post-correction-profile-heldout-score \ --frozen-eval-pack limbu-heldout-corrections-v1 ``` If the held-out score passes, write a new admitted profile instead of editing the profile by hand: ```bash uv run ocrtech admit-limbu-post-correction-profile \ outputs/limbu-post-correction-profile-derived/limbu-post-correction-profile.json \ outputs/limbu-post-correction-profile-heldout-score/limbu-post-correction-profile-eval.json \ --out outputs/limbu-post-correction-profile-admission ``` Audit the corrected bundle before using its text or correction pairs: ```bash uv run ocrtech audit-limbu-output outputs/limbu-page-corrected ``` ## Required Model Shape The intended model card is a `script_select_composite` candidate: - primary recognizer: Devanagari-written Limbu recognizer or strong Devanagari baseline - secondary recognizer: Sirijonga/Limbu recognizer - `script=limbu` - `routing_granularity=line` once both recognizers return aligned line boxes - `routing_signal_engine=secondary`, so the Sirijonga recognizer's own U+1900..U+194F output can trigger Sirijonga routing even when the Devanagari primary fails to emit Limbu codepoints - `primary_guard_script=devanagari` and `primary_guard_threshold=0.5`, so a primary line that is clearly Devanagari is not replaced by a Sirijonga recognizer hallucination - `secondary_structure_backfill=true` when the secondary engine has stronger page layout The current packaged router lives at `outputs/limbu-first-router-v1/model-card.json`. It uses Tesseract `nep+eng` as the Devanagari primary and the exported v4 PaddleOCR Sirijonga recognizer as the secondary. The Sirijonga backend uses `recognition_mode=auto`: normal page images still go through PaddleOCR detection, while wide/short line crops go straight to the lower-level PaddleOCR `TextRecognition` recognizer. That matters because the full PaddleOCR detector failed on a real Sikkim Herald Sirijonga line crop by detecting only a tiny blank edge strip; recognizer-only mode emits Sirijonga Unicode for that same crop. The v4 component was exported from `outputs/limbu-recognizer-v4-2026-06-18/limbu-v4.tgz` and packaged at `outputs/limbu-v4-paddle-package-2026-06-21/package/model-card.json`. The copied router component is `outputs/limbu-first-router-v1/components/limbu-sirijonga-paddle-v4/`. Both the component and router model-card audits pass, and the guarded runtime preflight passes under a Python 3.11 OCR environment on this machine: ```bash PYTHONPATH=src /tmp/ocrtech-paddle311/bin/python -m ocrtech.cli preflight-limbu-pipeline \ --model-config outputs/limbu-first-router-v1/model-card.json \ --out outputs/limbu-first-router-v1/runtime-preflight-py311-v4-guarded PYTHONPATH=src /tmp/ocrtech-paddle311/bin/python -m ocrtech.cli parse-limbu-doc \ path/to/prepared-page.png \ --out outputs/limbu-page-run \ --engine candidate \ --model-config outputs/limbu-first-router-v1/model-card.json ``` `preflight-limbu-pipeline` records this as `limbu-runtime-preflight.json` and `limbu-runtime-preflight.md`, including the router model-card audit, nested component model-card audit, Python executable/version, required Python modules, Tesseract binary, and required Tesseract language data. The repo's default `uv run` environment currently uses Python 3.14 and still fails Paddle/PaddleOCR imports; use the Python 3.11 runtime above for operational OCR until the project environment is moved to a Paddle-compatible Python. On macOS, Tesseract is installed through Homebrew. The full `tesseract-lang` package is large; if disk is tight, installing only `nep.traineddata` beside the bundled `eng` language data is enough for this router: ```bash brew install tesseract curl -L --fail -o /opt/homebrew/share/tessdata/nep.traineddata \ https://github.com/tesseract-ocr/tessdata/raw/main/nep.traineddata ``` The Python side needs the project OCR engine dependencies plus a platform-appropriate PaddlePaddle install so that `import paddle` and `import paddleocr` both pass. Use the preflight report as the source of truth after installation. Current machine note: `/tmp/ocrtech-paddle311/bin/python` has been recreated with Python 3.11.13, `paddle` 3.3.1, and `paddleocr` 3.7.0. The refreshed preflight at `outputs/limbu-first-router-v1/runtime-preflight-2026-06-21-py311-restored-paddle` passes the runtime dependency checks for `paddle` and `paddleocr`, but the overall router preflight still fails because the deployed Devanagari primary is explicitly marked failed after the CDC page diagnostic. The runtime is usable for Sirijonga measurement; the router is not ready until the Devanagari primary is replaced or re-admitted with evidence. Do not call this page-level OCR best-in-class until the detector, recognizer routing, and reading-order behavior have been evaluated on held-out page references. The existing strong Limbu number is an oracle-crop recognizer result, not a full page OCR result. The router model card at `outputs/limbu-first-router-v1/model-card.json` now records component admission explicitly: `devanagari_primary` is `failed`, while `sirijonga_secondary` remains `experimental` until full-page references are scored and the live crop/reading-order path is improved. ## Current Real Runtime Evidence As of 2026-06-21, the guarded v4 router has local real-asset checks and non-claim diagnostics: - Gorkhapatra Limbu language-page candidate, now confirmed as Namdhinggo/Sirijonga-script material rather than Devanagari-written Limbu: `outputs/limbu-dual-script-real-run-2026-06-21/gorkhapatra-devanagari-ocr-v4-guarded`. Capture audit and output audit pass. The run produced 98 OCR lines, 22 review lines, four detected tables, average line confidence 0.821, and a warning for low-confidence lines. Routing selected Tesseract for 7 guarded Devanagari lines and PaddleOCR for 91 Sirijonga-classified lines. The output directory still carries the older `gorkhapatra-devanagari` run name, but that is not evidence that the page is Devanagari-written Limbu. - Current-schema rerun of the same real Sirijonga page: `outputs/limbu-dual-script-real-run-current-2026-06-21/gorkhapatra-sirijonga-ocr-v4-current` was produced from a fresh `prepare-limbu-capture` bundle at `outputs/limbu-dual-script-real-run-current-2026-06-21/gorkhapatra-sirijonga-prep`. Capture audit passed; auto-deskew was conservatively skipped because the page had insufficient near-horizontal line evidence. The OCR run produced 92 lines, 4 tables, and 25 review rows, with script counts `limbu_sirijonga=79`, `devanagari_limbu=11`, `mixed_limbu_devanagari=1`, and `other=1`. Strict capture-plus-Sirijonga audit passed at `strict-audit-capture-sirijonga/limbu-output-audit.json` (SHA-256 `67fe54feab8f636996de78c36cb303e60c5799bdce2fbeca082a9cd2997ce564`). The stricter final policy audit intentionally fails with `strict Limbu output policy requires no pending review lines: review_line_count=25`; this output is current-format real triage evidence, not a finished digitization. Scoring that current-schema output against a derivative current-input copy of the non-claim Gorkhapatra draft reference at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/score-current-router-v4-current` gives codepoint CER 0.823802, grapheme CER 0.859202, line detection F1 0.010127, and 2/303 matched reference lines. The eval has no document source mismatch, but its audit is not claim-safe: the pack is one unreviewed machine-converted page, not frozen or claim eligible, and the train/dev leakage check has not been run. `compare-current-router-vs-live-v4-current` shows this current-schema run is slightly worse than the older guarded live-detector diagnostic, by -0.008158 absolute codepoint-CER and -0.001988 absolute grapheme-CER. Treat this as evidence that the current operational path is still in the same full-page failure regime, not as progress over the prior page output. Replaying the best local image-line diagnostic recipe on the same fresh prepared input gives a better but still unacceptable candidate route: `current-image-line-box-documents-width480-wide-rtl` uses Otsu thresholding, ink boxes, a 23x3 morphology kernel, 12 px crop padding, the width-480 Sirijonga line recognizer, and wide right-to-left order; `auto_layout` selects that order on this page from image features alone. The unpruned current-input score is codepoint CER 0.761144, grapheme CER 0.804042, line F1 0.833866, 261/303 matched references, and matched-line codepoint CER 0.106076. A precision-first confidence/script filter (`drop_empty`, confidence >= 0.85, require Sirijonga/mixed script) keeps 199/323 lines and scores better text but lower recall: codepoint CER 0.730446, grapheme CER 0.763956, line F1 0.792829, precision 1.0, recall 0.656766, and matched-line codepoint CER 0.036114. This is the current best diagnostic path for review triage, but it is not a full-page solution because it deliberately omits 104/303 reference lines plus other unmatched content. The route is now wired into `parse-limbu-doc` as `--line-detection-mode image-line`. The operational mode emits normal Limbu artifacts plus `image-line-ocr-run.json`, `image-line-crops/manifest.jsonl`, hashed image-line crop PNGs in `limbu-output-manifest.json`, and the usual script-aware review queue/dashboard. It also supports repeatable operational rescue detector passes with `--image-line-rescue-detector-pass key=value,...` and IoU dedupe via `--image-line-merge-iou-threshold`; emitted line/crop metadata records `detector_source_pass` and `image-line-ocr-run.json` summarizes detected, kept, and removed rows by source pass so primary and rescue detections remain auditable. Optional `--image-line-filter-drop-empty`, `--image-line-filter-min-confidence`, `--image-line-filter-require-script`, and relative geometry flags such as `--image-line-filter-min-width-ratio` expose precision-first triage modes; leave those filters off for fuller recall. The current admitted Sirijonga triage recipe is `--image-line-filter-drop-empty --image-line-filter-require-script sirijonga --image-line-filter-min-confidence 0.70 --image-line-filter-min-width-ratio 0.05`. Final audits for image-line outputs must include `audit-limbu-output --require-no-dropped-image-lines` so filtered partial outputs cannot pass by deleting low-confidence or short-fragment content. Running the operational mode itself on the current prepared page produced `outputs/limbu-operational-image-line-current-2026-06-21/gorkhapatra-width480-unpruned` with 323 kept image-line OCR lines, 0 dropped detected lines, 1 empty crop, 96 review rows, and script counts `limbu_sirijonga=293`, `other=30`. Its capture/Sirijonga/no-dropped strict audit passes (SHA-256 `ec5e62a13be875a86f16cb1725f7cbf586153adbc243d1df1adc3ede2a121300`), but final strict policy still fails with `review_line_count=96`. Scoring the operational bundle gives the same non-claim diagnostic metrics as the materializer route: codepoint CER 0.761144, grapheme CER 0.804042, line F1 0.833866, 261/303 matched references, and +0.062658 absolute codepoint-CER improvement over the current router. The operational precision-first run at `outputs/limbu-operational-image-line-current-2026-06-21/gorkhapatra-width480-prune-conf085` keeps 199/323 lines, removes 124, and has zero review rows. The previous strict final-policy pass without a dropped-line gate is superseded: `audit-limbu-output --require-no-dropped-image-lines` now rejects this bundle with `removed_line_count=124` (SHA-256 `a7527a6fe61c23bc37598ade9f8a8d9429b188a1616398e3f76c4f3639735fa4`). It remains a high-precision partial-output bundle. Its draft score is codepoint CER 0.730446, grapheme CER 0.763956, line F1 0.792829, precision 1.0, recall 0.656766, and +0.093356 absolute codepoint-CER improvement over the current router; do not treat the zero review queue as page completeness. The refreshed operational line-failure analysis at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/line-failure-analysis-operational-width480-minwidth005-conf070-v4` makes the remaining detector miss pattern explicit: 67 references are unmatched, only 2 high-IoU matches are bad-text rows, and 2,422/2,888 attributed codepoint errors are missed reference text. The miss concentration is horizontal, not simply top/bottom: center-band references are unmatched at 42/106 with 1,757 missed-reference codepoints, while left is 9/97 and right is 16/100. The worst combined bands are middle/center (20/42, error mass 810), bottom/center (14/45, error mass 664), and top/center (8/19, error mass 283). The v4 overlap diagnostic shows this is not primarily matched-line swallowing: 65/67 unmatched references have no overlapping prediction at all and only 2/67 reach IoU >= 0.30 against any predicted box. Next detector work should target no-component center-column body-line recall and false-line handling before another confidence-only prune. - Gorkhapatra Limbu Sirijonga page draft eval: `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21`. The accepted page `gorkhapatra-language-page-0001-01` has a PDF-native draft reference generated from `NamdhinggoSILL` spans with the `limbu-namdhinggo` converter. It has 303 reference lines, 36 spans with unmapped conversion issues, and remains explicitly non-claim (`gt_status=machine_converted_unreviewed`, `claim_evidence_eligible=false`). Scoring the existing guarded live-detector OCR output as `--ocr-output-kind live_detector` gives codepoint CER 0.815643, grapheme CER 0.857214, line detection F1 0.009975, and only 2 matched lines out of 303 references. The eval audit passes artifact consistency, but the run is not claim-safe because the pack is one page, not frozen, and not human verified. The oracle-line-box diagnostic at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/score-oracle-line-boxes-v4` forces the same v4 recognizer over all 303 reference boxes and scores at codepoint CER 0.029268, grapheme CER 0.060792, matched-line codepoint CER 0.030031, matched-line grapheme CER 0.063993, and line F1 1.0. The paired comparison `compare-oracle-vs-live-v4` shows a non-claim-safe codepoint-CER improvement of 0.786375, so this page is overwhelmingly a live detection/segmentation failure when the boxes are oracle-quality, not a same-font Sirijonga recognizer failure. A tuned morphology detector diagnostic at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/image-line-box-documents-v4-tuned` uses `tools/materialize_page_image_line_boxes.py` with Otsu thresholding, ink bboxes, horizontal kernel 23, vertical kernel 3, max line height 140, 2 px detector padding, and 12 px crop padding. It emits 323 lines, matches 261/303 references, and improves geometry to line F1 0.833866 with mean IoU 0.879406, but page text remains poor: codepoint CER 0.763835, grapheme CER 0.828226, matched-line codepoint CER 0.285785, matched-line grapheme CER 0.551916, and matched-line reading-order pair accuracy 0.606543 over 33,930 aligned-line pairs. The older raw `reading_order_pair_accuracy` remains 0.0 for this live detector because predicted IDs are `img-line-*` while reference IDs are `span-*`; use the matched-line reading-order metric for live detector diagnostics. Treat this as a useful detector prototype, not a solved page OCR path. A detector-only reading-order comparison at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/compare-detector-reading-order-column-major-v1` used `tools/compare_limbu_sirijonga_detector_reading_order.py` to compare `top_to_bottom` with `column_major` under the same tuned detector parameters; both modes score matched-line reading-order pair accuracy 0.606543, so the simple column-major switch is not a rescue. A detector-only parameter sweep at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/detector-param-sweep-v1` evaluated 1,680 morphology configs and found a small geometry improvement by keeping the 23x3 kernel but lowering `max_height` to 80: line F1 0.844660, precision 0.828571, recall 0.861386, 315 predicted lines, and the same 261/303 matches. This candidate can be approximated by filtering the already materialized tuned OCR document because the 315 candidate boxes are a strict subset of the prior 323 boxes. `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/score-image-line-detector-v4-tuned-maxheight80-filtered` shows that reuse-filtered candidate does not improve page text: codepoint CER remains 0.763835 and grapheme CER moves slightly worse from 0.828226 to 0.828392. It still leaves matched-line reading-order accuracy at 0.606543. A line-failure analysis at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/line-failure-analysis-image-line-detector-v4-tuned` joins line alignment with crop provenance and shows the dominant failure: 138/261 matched lines are high-IoU (>=0.85) but bad-text, versus only 11 low-geometry bad-text matches. Those high-IoU bad-text rows have mean IoU 0.893282, mean confidence 0.445911, mean codepoint reference length 45.17, mean crop width 330.88 px, mean crop aspect ratio 6.73, and mean grapheme CER 0.678634. The matched crop-width bands degrade from <=256 px codepoint CER 0.132605 / confidence 0.805627 to 769+ px codepoint CER 0.412653 / confidence 0.219722. The immediate next Sirijonga OCR artifact is the recognizer input-width ablation pack at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/recognizer-width-ablation-v1`, with 233 high-IoU matched crops and PaddleOCR line-recognition model-card variants for input widths 320, 480, 640, 960, and 1280. The restored Python 3.11 Paddle runtime scored all five variants with zero prediction failures. Width 480 is the winner on this diagnostic pack: codepoint CER 0.100651, grapheme CER 0.169567, and exact line accuracy 0.278970. Width 320 is much worse (codepoint CER 0.269910), and larger widths regress: width 640 codepoint CER 0.108741, width 960 codepoint CER 0.212755, and width 1280 codepoint CER 0.442740. Testing the same tuned page materialization with the width-480 model card improves matched-line codepoint CER from 0.285785 to 0.105977 and matched-line grapheme CER from 0.551916 to 0.178678, but it does not improve full-page text: page codepoint CER moves from 0.763835 to 0.770900 while matched-line reading-order accuracy remains 0.606543. Treat width 480 as the right Sirijonga line-recognition setting, but not a page-OCR fix by itself. A layout-specific `wide_column_right_to_left` ordering diagnostic improves Gorkhapatra matched-line reading-order pair accuracy from 0.606543 to 0.763985 with the same 261/303 matches and line F1 0.833866, but the same mode regresses the Sikkim draft from 0.992402 to 0.753361, so it cannot be a global Sirijonga default. `tools/materialize_page_image_line_boxes.py` now also exposes `--reading-order auto_layout`, which records requested and selected ordering plus layout features. The current heuristic selects `wide_column_right_to_left` only for wide pages with column-like regular line widths. On the same detector-only comparisons it matches the Gorkhapatra wide-RTL ordering gain (0.606543 -> 0.763985, result SHA-256 `9025a7fa5141f970425c22cfd20e29ebb78edadca60b6c6eec2bee0813541204`) while keeping Sikkim at `top_to_bottom` with zero ordering delta (0.992402 -> 0.992402, result SHA-256 `a28dff4c45be44d68916bd7df4f2961df74ac079c35e16b885bd5649eb886c12`). This is a layout-selection diagnostic, not a recognition improvement by itself. Scoring Gorkhapatra with width 480 plus this wide right-to-left order improves full-page codepoint CER from 0.770900 to 0.761228 and grapheme CER from 0.804207 to 0.803876, while matched-line codepoint CER remains 0.105977. This is useful signal, not a solved page OCR path: the paired sample count is 1, the run is not claim-safe, and the page is still dominated by false predictions, unmatched references, and assembly errors. `tools/analyze_page_line_failures.py` now has an unmatched-line diagnostic that writes `top-unmatched-references.csv`, `top-unmatched-predictions.csv`, and `near-miss-unmatched-pairs.csv`. On the current operational width-480 unpruned run, `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/line-failure-analysis-operational-width480-unpruned-v4` reports 261 matched rows, 42 unmatched references, 62 unmatched predictions, and only 15 high-IoU bad-text matches. The remaining missed references are not mostly easy threshold near misses: only 5/42 have an unmatched prediction with IoU >= 0.30 and 0/42 have IoU >= 0.50. The v4 analyzer now reports attributed codepoint error mass, spatial missed-reference bands, best-overlap against every predicted box, and operational image-line crop manifests that have line ids but no `sample_id`. On the unpruned route, `missed_reference_text` remains dominant at 1,416/2,919 attributed codepoints (0.485), and the center band accounts for 31/106 unmatched references plus 1,116 missed codepoints. Only 5/42 unmatched references reach IoU >= 0.30 against any predicted box and none reach 0.50; 28/42 have no overlapping prediction at all. The result JSON SHA-256 is `f540fe59bf23b4f9b81c67b8e21f6827a563336d999781132ca4a2b23732c4a0`, and the report SHA-256 is `a51ddce081e8d0989ce13bbaa90a575aa4887a5e69a2b70c0745f8d7d0c7b467`. On the current `minwidth005-conf070` operational route, the refreshed analysis at `line-failure-analysis-operational-width480-minwidth005-conf070-v4` reports 236 matched rows, 67 unmatched references, 2 unmatched predictions, only 2 high-IoU bad-text matches, and dominant error source `missed_reference_text`: 2,422/2,888 attributed codepoints (0.839). Its spatial bands show center horizontal coverage is the main miss source: 42/106 center references are unmatched with 1,757 missed codepoints, and the worst combined bands are middle/center, bottom/center, and top/center. Result SHA-256: `1da537b596b8c6e2b010998fc183289a8e632c75237d509c783b3977ba9e1c65`; report SHA-256: `d9fef331d97b94877f39b02b8ddf29445d97e96d44cfcaf16e93f6b15ba993ba`. This moves the next fix away from simply lowering match thresholds or splitting matched detections. Direct pixel inspection of the largest center-column misses shows the text is visible in the prepared image, but those rows fall inside one rejected Otsu/morphology connected component at `[995,401,326,1404]`; the detector was discarding a tall merged body component, not failing because ink was absent. A bounded adaptive-threshold branch was tested and rejected: `adaptive_mean:41:11` under the operational 23x3 settings raised matches from 261 to 263 but only reached F1 0.844302, and adaptive rescue on the `max_height=80` tuned route lowered F1 below the no-rescue 0.844660 baseline. The admitted detector-only recall fix is now tall-component splitting. `src/ocrtech/image_lines.py`, `tools/materialize_page_image_line_boxes.py`, and `tools/compare_limbu_sirijonga_detector_reading_order.py` expose opt-in `split_tall_components` / `--split-tall-components`, row-projection settings `split_tall_row_min_ink=2` and `split_tall_max_row_gap=4`, and provenance `detector_source_pass=primary-split-tall`. On Gorkhapatra, the reproducible detector-only run at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/compare-detector-split-tall-maxh80-v1` uses Otsu, ink boxes, 23x3 morphology, `max_height=80`, detector padding 2, and tall splitting; it reaches 285/303 matches, 339 predictions, precision 0.840708, recall 0.940594, F1 0.887850, mean IoU 0.869405, and wide-RTL matched reading-order pair accuracy 0.712824. Result SHA-256: `06c242545dce5462dcfb25773b71045c1c3cde026843751d62d2c3a7f44a07c3`; report SHA-256: `f9dd7e679f733937a5b793e45e38eb02394c8b3fb80fc3f8eb039b3ac770e82c`; alignment TSV SHA-256: `44feb8ba76840f85b008c0a1c773b3a033d1b11637e3f002ceebcdab23ae7414`. Full OCR materialization has now been run and rejects split-tall as an admitted page route by itself. `image-line-box-documents-v4-split-tall-width480-wide-rtl` was materialized with the v4 width-480 line recognizer, `recognition_mode=line`, 339 lines, and 0 empty predictions. Run SHA-256: `80808cefbc3804b0385a6c2a2fe16522ebe1a7c307b9447210006905d1712c96`; crop manifest SHA-256: `7e6b62b25ef17687897034ed70eb1bf09c3d50a407d8a786707825cbd4a99cc5`; document SHA-256: `da1a1664aee6beb1381ed338f884033c44e5c3a17d9bc9b610f86f778b97563b`. Scoring at `score-image-line-detector-v4-split-tall-width480-wide-rtl` gives page codepoint CER 0.791421 and grapheme CER 0.831042, worse than the non-split wide-RTL score 0.761228 / 0.803876. Metrics SHA-256: `db52ef81012890dbe77179b9deadb72adb04f90c9228cffd2b68860ae5902b18`; run SHA-256: `33977edad6ff145a24891ecfda9b990f0895074c5043ef902a4ba46f92c8e990`. The paired comparison at `compare-split-tall-width480-wide-rtl-vs-tuned-width480-wide-rtl` reports negative absolute improvement: codepoint -0.030193, grapheme -0.027166; comparison SHA-256 `86906240daae771ba960cbd725b19210bde3eb08d4a2d3c4d95e37ca9610835e`. The failure shape changed: `line-failure-analysis-split-tall-width480-wide-rtl-v1` shows 285 matches, 18 unmatched references, 54 unmatched predictions, and `missed_reference_text` error mass down to 425, but page assembly is now dominated by matched bad text/extra prediction text and worse reading order (0.712824 versus the previous wide-RTL 0.763985). Analysis SHA-256: `b3d8266031538bce0c63f38f6db4e2f485ac2e18fe26f9fcda4bc3408f05524d`; report SHA-256 `eef5b226a0f60f203501a6c0c2ab48166fd5e159bf91f559df70a4f5c79a64e0`. Pruning without fixing order does not rescue split-tall enough: `ocr-line-pruning-sweep-split-tall-width480-wide-rtl-v1` has best threshold 0.85 with codepoint CER 0.740875 and grapheme CER 0.768759 (sweep SHA-256 `085765fe1264ec1b45e879cf2677539eb1436f208a5a2e6a01e9b88cea1d1e5f`), still worse than the older non-split Gorkhapatra-only conf085 result 0.730362 / 0.763956. The clean comparison at `compare-split-tall-conf085-vs-tuned-width480-wide-rtl-conf085` gives codepoint improvement -0.010513 and grapheme -0.004804 (comparison SHA-256 `4cc4b640ca0ab5e1c6beaac2badeae0f1acf1378674b3c4ccc9a8d67eda92068`). A source-pass-aware ordering mode was added: `wide_column_right_to_left_split_tall_last`. It keeps the existing wide-RTL order for primary boxes and places `*-split-tall` boxes after primary boxes. Detector-only comparison at `compare-detector-split-tall-wide-rtl-last-v1` improves split-tall matched-line reading-order accuracy from 0.712824 to 0.765654 with the same 285/303 matches and F1 0.887850; comparison SHA-256: `cce99e017e0e3565c50e56d8886588910d567e94685d8f302e703f155347c636`. Full OCR at `image-line-box-documents-v4-split-tall-width480-wide-rtl-last` scores codepoint CER 0.778638 and grapheme CER 0.820938, better than plain split-tall but still worse than non-split wide-RTL before pruning. With the same non-oracle confidence sweep, `ocr-line-pruning-sweep-split-tall-wide-rtl-last-v1` reaches best conf085 codepoint CER 0.730614 and grapheme CER 0.763624 (sweep SHA-256 `869381446576317d8258f36557bec4e7da0171e3f613ada59f4c8e44a9b3ca6f`). Against the previous non-split conf085 Gorkhapatra result, the clean comparison at `compare-split-tall-wide-rtl-last-conf085-vs-tuned-width480-wide-rtl-conf085` is a near-tie: codepoint -0.000252, grapheme +0.000331; comparison SHA-256 `cfbb25555feab3af1d4863f4f654efd11b94bb18dde047b0b9d2890a330a71f9`. Sikkim cross-page detector validation rejects global admission. Without tall splitting, `compare-detector-split-last-no-split-v1` keeps Sikkim at 59/86 matches and F1 0.559242, but drops matched-line reading-order accuracy from 0.992402 to 0.753361 (comparison JSON SHA-256 `014bdc6c9fd08d7f82b8292cdcfe0e0a6a08dd2a2a6a6e3a79024e51d7acc813`). With `--split-tall-components`, `compare-detector-split-tall-last-v1` adds one prediction without adding matches, lowering F1 to 0.556604 while preserving the same order regression to 0.753361 (comparison JSON SHA-256 `77d2bd30cfc2ed0a2827704c0bf21b51ec3698af3aedb1cc3459382530a9b6fc`). Full OCR materialization is intentionally skipped for Sikkim because the detector-only gate already fails. Keep `wide_column_right_to_left_split_tall_last` as a Gorkhapatra/layout-specific diagnostic, not as a global Sirijonga route. The safe follow-up is now implemented as `auto_layout_split_tall_last`: it first detects without tall splitting, uses the existing auto-layout gate, and only reruns tall splitting plus split-last ordering when the page qualifies as a wide-column layout. Detector-only Gorkhapatra validation at `compare-detector-auto-layout-split-tall-last-v1` keeps 285/303 matches, F1 0.887850, and improves matched-line reading-order accuracy from 0.712824 to 0.765654 (comparison JSON SHA-256 `6364dd87e617b3b76236ea37d71b08fab216d5c5ffb8a3b08d6b03560581237b`). Sikkim validation at `compare-detector-auto-layout-split-tall-last-v1` selects top-to-bottom, keeps 59/86 matches, improves F1 back to 0.559242 by avoiding the split false-positive, and preserves matched-line reading-order accuracy at 0.992402 (comparison JSON SHA-256 `5aa325d176af4a85dda65a3e3684ae9c80bc7c9a7485e0cb7e0729f8fddf20e7`). Full OCR materialization confirms the route behavior: Gorkhapatra emits 339 lines with `wide_column_right_to_left_split_tall_last`, scores codepoint CER 0.778638 / grapheme CER 0.820938, and exactly matches the explicit split-last OCR score (`compare-auto-split-tall-vs-split-tall-wide-rtl-last` JSON SHA-256 `9326ef4b2e33964d985c734b34ba824977658887ee3ee6f61f7ab8cb724c3b61`); Sikkim emits 125 primary lines with `top_to_bottom`, scores codepoint CER 0.460255 / grapheme CER 0.576710, and exactly matches the existing image-line baseline (`compare-auto-split-tall-vs-image-line-v4` JSON SHA-256 `50b845f80d1212eb2c751ba43070880602c70c506f6682e9f8e1ca0266802e7e`). This is a safer candidate branch, not an admitted final policy: the Gorkhapatra unpruned page score is still worse than the non-split wide-RTL score, and claim safety remains blocked by draft machine-converted one-page references. Running the gated branch through the same non-oracle pruning/admission layer confirms that boundary. `ocr-line-pruning-sweep-auto-split-tall-minwidth005-v1` reaches a Gorkhapatra local best at conf085, codepoint CER 0.730614 / grapheme CER 0.763624, but Sikkim regresses badly at conf085 to codepoint CER 0.702650 / grapheme CER 0.731978. Cross-page admission at `outputs/limbu-sirijonga-auto-split-tall-pruning-threshold-admission-2026-06-21` therefore selects conf070, with Gorkhapatra codepoint CER 0.753406 / grapheme CER 0.782508 and Sikkim codepoint CER 0.423454 / grapheme CER 0.511091; admission JSON SHA-256 is `2bc16296a6295a03482ef30a01729c5ae7b37278c6623ca38d6431d86a3665ed`. Direct comparison against the already-admitted non-split minwidth005 conf070 route rejects promotion: Sikkim is tied exactly, but Gorkhapatra regresses by 0.014045 codepoint CER and 0.014245 grapheme CER (`compare-auto-split-tall-minwidth005-conf070-vs-non-split-minwidth005-conf070` JSON SHA-256 `f26b0911a4ba92bce47ea53bee0af6f88a5ef93f61f6361586daacd74d814b70`). Keep auto-split-tall as a diagnostic/alternative for recall analysis, not the admitted operational pruning route. The operational `parse-limbu-doc` path now has the same rescue-pass family for real OCR runs; `tools/materialize_page_image_line_boxes.py` and `tools/compare_limbu_sirijonga_detector_reading_order.py` now support repeatable `--rescue-detector-pass` morphology passes with IoU-based merge dedupe and recorded `detector_source_pass` provenance. This creates an auditable way to test multi-pass coverage before running recognition. On the same Gorkhapatra page, the broad rescue passes are not good enough: `h15,v1,min_width=20` raises matches from 261 to 281 and recall from 0.861386 to 0.927393, but explodes predictions to 702 and drops F1 to 0.559204. The best conservative tested pass `h41,v1,min_width=250,min_area=250,max_height=80,merge_iou=0.30` reaches 264 matches and recall 0.871287, but still lowers precision to 0.774194, F1 to 0.819876, and matched reading-order accuracy to 0.756596 versus the no-rescue baseline F1 0.833866 / order 0.763985. Its comparison JSON SHA-256 is `088fdca2fe6865f66998bdd10a41908240232a271ce5567a62a4528e7c02c431`. Treat this rescue-pass support as an experiment harness, not an admitted detector improvement. The same harness now supports `min_aspect_ratio`/`max_aspect_ratio` gates for both primary and rescue detector passes. Aspect-gating the conservative rescue pass at `min_aspect_ratio=8` does not admit it: the best aspect-gated result still has 341 predictions, 264 matches, precision 0.774194, recall 0.871287, F1 0.819876, and matched reading-order accuracy 0.756596, below the no-rescue baseline. Its comparison JSON SHA-256 is `75934afe974a8189b97b18f61c82dde1d5d87bdbf9a540c93c6ae4aac0f75156`. `tools/filter_page_ocr_documents.py` now adds a non-oracle OCR-line pruning diagnostic that can drop live lines by empty text, confidence, target script, and geometry while preserving page-eval document compatibility and writing line-level removal reasons. `tools/sweep_page_ocr_line_pruning.py` wraps that filter with page eval and paired comparison so threshold admission is measured, not copied from a single page. `tools/audit_page_ocr_line_filter.py` replays the filter from the source OCR documents and verifies filtered `document.json` files, line reports, source hashes, and kept/removed counts; current pruning sweeps run this audit for every threshold candidate. On Gorkhapatra width-480 wide-RTL output, the automated sweep at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/ocr-line-pruning-sweep-width480-wide-rtl-v1` confirms pruning empty/non-Sirijonga lines plus confidence thresholds improves page codepoint CER: 0.50 -> 0.746678, 0.60 -> 0.744996, 0.70 -> 0.739697, 0.80 -> 0.738436, 0.85 -> 0.730362, then 0.90 regresses to 0.760387. The best tested Gorkhapatra candidate keeps 199/323 live lines and improves over unpruned wide-RTL page CER 0.761228 by 0.030866 absolute, but remains one-page, draft-reference, non-claim evidence; its standalone filter audit passes with 0 issues (`561aae44bf6bc7e5cb5924e969d9eb8d8c41fcfcbcc5958b2888ab6390242258`). The Sikkim sweep at `outputs/limbu-page-eval-drafts/sikkim-sirijonga-2020-12-03-page1-v1/ocr-line-pruning-sweep-image-line-v4-v1` is the counterexample: 0.85 pruning hurts codepoint CER from 0.460255 to 0.694308, while milder 0.70 pruning keeps 107/125 lines and improves codepoint CER to 0.444063. Its standalone filter audit also passes with 0 issues (`581dd1d3c0e07a6210f3fe940efa70fe8e0b998095733c60c57b038b1602f9b4`). `tools/admit_page_ocr_line_pruning_threshold.py` now performs cross-page operational threshold admission from these per-page sweeps instead of copying the best single-page threshold, and the report records each admitted page's exact documents, score, comparison, and audit hashes. The current admission run at `outputs/limbu-sirijonga-pruning-threshold-admission-2026-06-21` requires common thresholds across Gorkhapatra and Sikkim, passing filter audits, and no page-level codepoint/grapheme regression. It selects `conf070`: Gorkhapatra improves codepoint CER by 0.021531 and Sikkim improves by 0.016192. It explicitly rejects `conf085` because Sikkim regresses by -0.234053 codepoint CER and -0.148799 grapheme CER. Admission JSON SHA-256 is `cc8b0b8986c273bafbc73fc74ffc706dd28eeb93343c921aa4572411aae06429`; Markdown SHA-256 is `9e8672e71d58ae501ddd7024acf34a074ead09b12627cf81f1bff6e3b398b6e5`. `tools/audit_admitted_page_ocr_candidate.py` now audits the admitted candidate's residual line-alignment failures. The current `conf070` audit at `outputs/limbu-sirijonga-conf070-residual-audit-2026-06-21` reports 296 matched lines, 93 unmatched references, 51 unmatched predictions, 13 unmatched-reference near misses at IoU >= 0.30, 0 high-IoU unmatched references at IoU >= 0.50, and 26 matched high-text-error rows. Gorkhapatra is now mostly a recall problem (238 matched, 65 references missed, only 2 prediction-only lines; precision 0.991667). Sikkim remains both recall and false-line dominated (58 matched, 28 references missed, 49 prediction-only lines; precision 0.542056). The audit now also buckets residual geometry. Gorkhapatra missed references are mostly short boxes (51/65) concentrated in center and bottom/middle zones; Sikkim misses are mostly medium-width lines (22/28), with bottom-zone misses (13/28), while its prediction-only errors are overwhelmingly short boxes (47/49). The refreshed residual audit now also replays the admitted per-page score/comparison/filter artifact hashes and reports `artifact_integrity_passed=true`. Residual audit JSON SHA-256 is `28b0edcb15eaf4a3860e2560872ecd419ad5226f88964bf04feaa58104149f64`; Markdown SHA-256 is `178ce581a9829294da482916880ce9a19df0e103a4f272a4b7b7e11ab44e2516`. This is operational, non-claim threshold evidence only; the next page-level work is detector/layout recall for Gorkhapatra short/body misses and Sikkim-specific false-line handling around the stronger 480-wide line recognizer, not morphology-only tuning or a hard-coded ordering/pruning rule. A follow-up relative-geometry pruning sweep now extends `tools/filter_page_ocr_documents.py` and `tools/sweep_page_ocr_line_pruning.py` with page-relative width/height ratio filters that are replay-audited by `tools/audit_page_ocr_line_filter.py`. The real sweep uses `min_width_ratio=0.05`, `drop_empty`, Sirijonga script filtering, and confidence thresholds `0,0.50,0.70`. The cross-page admission at `outputs/limbu-sirijonga-pruning-threshold-admission-minwidth005-2026-06-21` selects `conf070` again, with mean codepoint-CER improvement 0.029334 and worst-page improvement 0.021867. It improves Gorkhapatra to codepoint CER 0.739361 (238/323 kept) and Sikkim to 0.423454 (82/125 kept). Admission JSON SHA-256 is `808a2e08fd853fbc1c612b398e37fe4903808a141a642b82d3338a3f64e632e4`; Markdown SHA-256 is `09d9d2296f72499c57156b7b4aaca89a13cbcbece82c3a800e53e74d8e247851`. The residual audit at `outputs/limbu-sirijonga-conf070-minwidth005-residual-audit-2026-06-21` shows why this is still only a triage candidate: total prediction-only rows drop from 51 to 28, and Sikkim prediction precision rises to 0.682927, but total missed references rise from 93 to 97 and Sikkim recall drops to 0.651163. Residual JSON SHA-256 is `969868c2eac5decc1a2a4a82848f0c051adbd04c5092d7d010b31698b818e2f5`; Markdown SHA-256 is `7ca5de60bd49d959a0f14ef96a56228400b42e46b9c0071dc78b8a497c7226d4`. Use this relative-width candidate for precision-oriented review triage, not as a complete page OCR policy. A same-row component merge diagnostic now adds an opt-in detector stage that merges horizontally adjacent fragments only when same-row, gap, center-delta, and maximum merged-width gates pass. It is wired through `parse-limbu-doc`, `tools/materialize_page_image_line_boxes.py`, and `tools/compare_limbu_sirijonga_detector_reading_order.py` as `merge_same_row_components=false` by default. With `y_tolerance=8`, `max_gap=120`, `max_center_delta=300`, and `max_width=420`, detector-only F1 improves Sikkim from 0.559242 to 0.875000 (90 predictions, 77/86 matches; JSON SHA-256 `379960a430a943e6076499eff5a744e084f736134a2e0579ad900e97e9dd7aa8`) and Gorkhapatra from 0.833866 to 0.875000 (289 predictions, 259/303 matches; JSON SHA-256 `1b2fdcdb08375ac5896487b66711787e5c59a7566dc88b60fe6e396ca2903421`). OCR scoring shows the trap: unpruned same-row merge improves Sikkim codepoint CER from 0.460255 to 0.418057, but Gorkhapatra remains worse than the admitted operational route. Running the same `drop_empty`, `require_script=sirijonga`, `min_width_ratio=0.05` confidence sweep selects `conf070` across pages at `outputs/limbu-sirijonga-same-row-merge-pruning-threshold-admission-2026-06-21` (admission JSON SHA-256 `970a1ad210423d430687d1666f190aa1c4795f516e9998bc4c544a086e45d32f`; Markdown SHA-256 `2cbad5bea8d40ca4a4b49690b705838b306cebe93ac09135887fd0f39ca57c7b`). The selected row-merge `conf070` improves Sikkim versus the already-admitted minwidth005 `conf070` route (codepoint CER 0.412169 vs 0.423454; comparison JSON SHA-256 `c4a5f5a2c24f92c678b91098d31b2874546d21fd79347368bc0e5862ebb4c079`), but regresses Gorkhapatra (0.744239 vs 0.739361; comparison JSON SHA-256 `bf8902a27aadc731452990b010be60b125b4fc6cf842f287f8faaeb5aa597aaf`). Do not globally promote same-row merge. Treat it as a conditional top-to-bottom fragmented page repair candidate; wide-column pages still use the existing non-merge operational path until a measured layout gate proves otherwise. That measured gate now exists as `merge_same_row_auto_fragmented_top_to_bottom`: it first resolves layout on unmerged boxes, only considers `top_to_bottom` pages, and requires at least 8 boxes and 18% line-count reduction from same-row merging before applying the repair. With this gate, Sikkim keeps the 90-line merged detector result and matched reading-order accuracy 0.990089, while Gorkhapatra stays on the 323-line non-merge wide-column path. Detector comparison JSON SHA-256s are `f5a50caaac7ee1eaea2bac4b39917cdb04e5ce8c1c622b620e9dad63e8e5b1f1` for Sikkim and `da5d57bb77fd1eb2b1f29a69f8b491623631d24e9a8dfccd06a1e7491cbd0d21` for Gorkhapatra. The gated OCR/pruning admission at `outputs/limbu-sirijonga-auto-same-row-merge-pruning-threshold-admission-2026-06-21` selects `conf070` (JSON SHA-256 `2784674a4b8ff7382086a9d1c544c25729df5f938a792b21b67d81298c9bfeed`; Markdown SHA-256 `81894b8ee2ea515f97523baa42217ba4ca4fe0f7ad0e67610b78daba33e3835c`). Against the previously admitted minwidth005 `conf070` route, the gated candidate improves Sikkim codepoint CER from 0.423454 to 0.412169 and grapheme CER from 0.511091 to 0.505545, while tying Gorkhapatra at 0.739361 / 0.768262. This is now the stronger operational candidate for the two draft Sirijonga pages, still bounded by the same non-claim limitations: draft references, two pages, and no native-reader adjudication. The same recipe has now been run through the live `parse-limbu-doc` path on the current Gorkhapatra prepared page at `outputs/limbu-operational-image-line-current-2026-06-21/gorkhapatra-width480-minwidth005-conf070`. It detects 323 image lines, keeps 238, removes 85, and leaves 39 review rows. The capture/Sirijonga audit passes (`e6a97c5949e81cc0194b296e9cb44a9886536229c35b7aa41cd6156421201541`), but strict final policy with `--require-no-dropped-image-lines` fails (`cf07d072c55c5ab282c9ed3dd9d54dc61e47c931689e4ba029d162dab51762ef`) because review rows and dropped image-line rows remain. Scoring that exact operational output against the one-page Gorkhapatra draft eval gives codepoint CER 0.739361 and grapheme CER 0.768262 at `outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/score-operational-image-line-width480-minwidth005-conf070`; metrics JSON SHA-256 is `14d0da1bf80e5afb876adfa6191501f2f18039dc86014123d7cf0d64551c4176` and eval audit JSON SHA-256 is `37c6d0e0efb74d3c61b7a5bd9f3ce5bf4caf0487d47d96ba1f42e7aabfb8b6a9`. The eval audit now passes structurally but is intentionally not claim-safe: the pack is unfrozen, machine-converted/unreviewed, one page only, and leakage checking against `recognizer-width-ablation-v1/manifest.jsonl` records 233 checked rows with `source_sample_id` overlap on `gorkhapatra-limbu-sirijonga-0001-01`. - Sirijonga geometry review now has a non-native-reader path: `tools/prepare_line_box_review_packet.py` builds a geometry-only line-box packet from page eval manifests and reference-seeded boxes, and `tools/audit_line_box_review_packet.py` audits hashes, image dimensions, bbox bounds, unique IDs, valid review statuses, and contiguous reading-order indexes. `tools/apply_line_box_review_packet.py` is the ingestion gate for completed geometry review: it refuses `pending` rows by default, applies accepted/corrected boxes, drops deleted boxes, and writes detector/layout references with empty `text` plus `claim_evidence_eligible=false`. The current packet at `outputs/limbu-sirijonga-line-box-review-packet-2026-06-21` covers the two real Sirijonga draft pages: Gorkhapatra plus Sikkim, 389 seeded line boxes total (303 + 86), `audit_passed=true`, and 0 issues. It intentionally contains no reference transcription, so it can calibrate layout/reading-order review without a native reader. Applying it currently blocks because all 389 rows are still `pending`. This does not certify text ground truth; it only makes detector and layout work reviewable. - Devanagari-written Limbu smoke page draft: `outputs/limbu-page-eval-drafts/limbu-devanagari-smoke-page-2026-06-21`. This uses real local Devanagari Limbu text from `data/synthesis-text/cdjk-rai-limbu-2026-06-16/toolkit-parallel-text.jsonl` (`bible_brain/LIFWBT_Limbu` rows), but it is a synthetic rendered page, not a real page capture. The pack has 1 page, 14 rendered lines, script `Devanagari`, source-text manifest SHA-256 `eb16b5fe0535bd3717b259d3d3d9261b02f8931264cc6791b997c1e92b5d9eb3`, image SHA-256 `d56055b686652226124bcf0d547a9bc2ad534046e032d7ba66d663e29888aa1b`, reference SHA-256 `f24cf4e86eee07f150bdc78b50b292ba19a1852cb49a90e60a4e883230b298e5`, and pack content SHA-256 `8a44efc5d89f22ff055269aa3bbf7fe30d088381bbdaf7e83be827b4ab8d493a`. The sidecar-perfect score at `score-sidecar-perfect` is an eval-harness smoke check: codepoint CER 0, grapheme CER 0, line F1 1.0, matched-line reading-order pair accuracy 1.0 over 91 pairs, and no missing required graphemes in the script inventory. Its audit passes artifact consistency but remains `claim_safe=false` because the pack is synthetic, not frozen, one page, and not human verified. This proves we can exercise Devanagari Limbu page-eval plumbing; it does not satisfy the real Devanagari-written Limbu page requirement. - Limbu page-source inventory gate: `outputs/limbu-page-source-inventory-2026-06-21`. The command `uv run tools/inventory_limbu_page_sources.py --out outputs/limbu-page-source-inventory-2026-06-21` inspected curriculum page metadata, Sikkim Herald Limbu PDFs, Gorkhapatra Limbu listings, local Devanagari text sources, and the synthetic Devanagari smoke pack. It reports 36 records, 3 real Devanagari page candidates, 3 Devanagari text-only sources, 1 Devanagari synthetic smoke pack, and `ready_for_real_devanagari_page_eval_draft=true`. The three curriculum sources (`Maths`, `Science`, `Social`) are now backed by real CDC Limbu PDFs fetched from `lib.moecdc.gov.np` using refs 3757, 3756, and 3758: `mero_ganit_grade1_limbu.pdf` (111 pages, SHA-256 `25fb14113adeb8ca474de70d26bd53455ae7b424de9e92eb43d9028b11e4d186`), `mero_vigyan_swasthya_grade1_limbu.pdf` (89 pages, SHA-256 `c24178a1789cad5cd209f9dccc8de54c7aa35cf28d7e5966221ccdd2ff2ee97e`), and `samajik_adhyayan_grade1_limbu.pdf` (87 pages, SHA-256 `d32366b3a4f80b44817ba633cf25bc3395d3c3df7a418f7999c902d71e938502`). Running the same inventory with `--require-real-devanagari-page` now exits 0. This removes the real-source blocker for a Devanagari page-eval draft, but it is still not claim-ready: the curriculum lines need page-image rendering, line/reference alignment evidence, and human or spot-check review before quality claims. - Devanagari-written Limbu CDC curriculum page draft: `outputs/limbu-page-eval-drafts/limbu-devanagari-cdc-curriculum-2026-06-21`. The builder `tools/build_limbu_devanagari_curriculum_page_eval_draft.py` renders real CDC Limbu PDF pages and pairs them with the curriculum JSON line text. The current pack contains three real page images: Maths page 8 with 14 lines, Science page 9 with 9 lines, and Social page 9 with 8 lines. Pack content SHA-256 is `d587e9ee5cc2983f761142c18de071c2578218d41341b5b2058409e1294ef333`; manifest SHA-256 is `2a708b3dbd444a05329343482452648e1cc3ecc34954860c95e2935737c10522`. The sidecar-perfect score at `score-sidecar-perfect` verifies text/reference plumbing: 3/3 pages scored, codepoint CER 0, grapheme CER 0, text exact accuracy 1.0, and reading-order pair accuracy 1.0. It also confirms the real limitation: reference coverage has text=3 and reading_order=3, but line_bboxes=0 and line_alignment_scored=0. The score audit is intentionally not passed and not claim-safe because there are no line-bbox references, no layout references, only three pages, the pack is not frozen, and the GT status is `curriculum_text_unreviewed`. This closes the "real Devanagari page draft exists" gap; it does not close the claim-grade Devanagari eval gap. A follow-up line-box draft exists at `outputs/limbu-page-eval-drafts/limbu-devanagari-cdc-curriculum-linebox-2026-06-21`. It uses the same three page images, but aligns PDF word-group boxes to the curriculum reference lines. The line-box pack has pack content SHA-256 `e696a92dee7ac49b4e81659aee7fb344af4c8fa0d4741c6cd43ef074cd052200`, `line_box_source=pdf_words_machine_aligned`, and line-bbox reference coverage for all 3 pages. Science drops 2 private-use marker PDF lines; Social drops 2 extra trailing PDF lines. The sidecar-perfect score at `score-sidecar-perfect` audits cleanly but remains `claim_safe=false`; it verifies the line-layout harness with codepoint CER 0, grapheme CER 0, exact page accuracy 1.0, matched-line CER 0, reading-order pair accuracy 1.0, and line detection F1 1.0. These line boxes are still machine-aligned, not human-verified claim evidence. Running the current Devanagari primary path on the same pack as `parse-limbu-doc --engine tesseract` produced auditable but poor live outputs at `live-tesseract-documents`; all three `audit-limbu-output` checks pass. The page score at `score-live-tesseract-primary` is not claim-safe, but the quality signal is still clear: 3/3 pages scored, codepoint CER 0.897862, grapheme CER 1.390169, exact page accuracy 0, line-bbox coverage 0, and all 58 detected lines entered review. By page, codepoint CER is 0.867220 for Maths, 0.908257 for Science, and 0.927536 for Social. The emitted text is largely Latin/garbled mixed output rather than clean Devanagari Limbu, so `nep+eng` Tesseract is not an adequate Devanagari-written Limbu primary for these pages. A quick PSM/upscale sanity check did not rescue it; the best tested setting was still roughly 0.87 codepoint CER. The same Tesseract baseline was rerun on the line-box pack. It audits cleanly as a non-claim diagnostic and repeats the bad page-text result: codepoint CER 0.897862, grapheme CER 1.390169, exact page accuracy 0. Against the new line references, its line detection F1 is only 0.385568 and matched-line codepoint CER is 0.869087. A morphology line-detector diagnostic at `image-line-box-documents-tesseract` detected 83 line-like boxes and ran Tesseract on the crops; 12 crop predictions were empty. The line-box-pack score at `score-image-line-tesseract` improves page text only slightly to codepoint CER 0.865400 and grapheme CER 0.937020, with exact page accuracy 0, line detection F1 0.400301, and matched-line codepoint CER 0.872156. The paired comparison at `compare-image-line-vs-fullpage-tesseract` shows a non-claim-safe codepoint-CER improvement of 0.032462 over full-page Tesseract. This is a detector/crop diagnostic, not a solution: line cropping helps a little, but the Devanagari CDC pages are a legacy visual-register OCR problem and need a same-register recognizer/data path plus better detection. - Devanagari-written Limbu CDC recognizer crop draft: `outputs/limbu-recognizer-eval-packs/limbu-devanagari-cdc-line-crops-2026-06-21`. This pack is built by `tools/build_limbu_devanagari_line_crop_recognizer_pack.py` from the CDC line-box page pack. It crops the real rendered CDC page images by the machine-aligned line boxes, writes PaddleOCR-style `eval.txt`, and preserves raw PDF legacy strings, source page, source bbox, crop bbox, image hashes, and claim flags in `manifests/recognizer-eval.jsonl`. It contains 31 real line crops, pack content SHA-256 `6d76ab654a0c210a1291f397f2274878d116713a91010ccc91a62cf892ea09b0`, and `line_box_source_counts={"pdf_words_machine_aligned": 31}`. The sidecar-perfect recognizer score verifies the pack is runnable: 31/31 matched lines, codepoint CER 0, grapheme CER 0, exact line accuracy 1.0. The diagnostic `nep+eng` Tesseract crop run at `score-tesseract-nep-eng` has 31/31 matched predictions but codepoint CER 0.852632, grapheme CER 0.857143, and exact line accuracy 0. This is now the cleanest Devanagari recognizer target: it removes page detection from the measurement and still shows generic Tesseract failing on the CDC visual register. A follow-up legacy-target analysis at `legacy-target-analysis-tesseract-nep-eng` compares the same Tesseract predictions against both labels available for each crop: Unicode Devanagari curriculum text and raw PDF legacy word text. Tesseract is not closer to the raw legacy strings: Unicode codepoint CER is 0.852632, raw legacy codepoint CER is 0.880213, and the analysis sets `legacy_string_ocr_shortcut_supported=false`. So the likely path is not "OCR the legacy Latin bytes, then transduce"; it is a same-register visual recognizer trained or adapted on CDC-like line crops, with the raw legacy strings kept as provenance and alignment evidence. - Devanagari-written Limbu CDC line-crop corpus: `outputs/limbu-recognizer-eval-packs/limbu-devanagari-cdc-line-crop-corpus-devclean-2026-06-21` is the current same-register training/dev/eval artifact. It is built by `tools/build_limbu_devanagari_cdc_line_crop_corpus.py` from all aligned CDC curriculum pages. Alignment coverage is complete for the local curriculum source: 281/281 text pages align, yielding 6,446 raw line crops before leakage filtering. The first large corpus had a 501-row dev split with train/dev leakage, so it should not be used for model selection. The dev-clean corpus excludes train/dev rows that overlap the held-out eval split by image hash, sample hash, or text hash, then also excludes dev rows that overlap train by those keys. It leaves 5,551 train, 258 dev, and 31 sealed eval rows across 254/24/3 pages. Corpus pack SHA-256 is `36f10b8b123b792f643e206ca59e3bfd9ce03d5357b5de7ed1cdaba2b92145d1`; eval split SHA-256 remains `6d76ab654a0c210a1291f397f2274878d116713a91010ccc91a62cf892ea09b0`. Both the train/dev audit and the combined train+dev versus held-out eval audit pass under Limbu-specific thresholds with real rows and no leakage. The eval Tesseract baseline from the identical sealed split still fails at codepoint CER 0.852632, grapheme CER 0.857143, exact line accuracy 0.0, and the eval legacy-target analysis again reports `legacy_string_ocr_shortcut_supported=false`. - Devanagari-written Limbu PP-OCRv5 training bundle: `runs/limbu-devanagari-cdc-ppocrv5-mobile-training-bundle-2026-06-21` packages the dev-clean corpus train/dev rows, staged images, a PP-OCRv5 mobile recognizer recipe, and a passing corpus audit. Archive SHA-256 is `01b3689603309c13cb31ef31ff7dc0def65b556a92269d33483ee11da6e8c14d`; bundle manifest SHA-256 is `95322aa852b14662e22c53ddbc1ae8346f37a51a7d1ae8348ec4f7a5fbf8da9f`. After extraction, run `python PaddleOCR/tools/train.py -c training-recipes/ppocrv5-mobile-devclean/paddle_recognizer.yml`. The sealed 31-line eval split is intentionally not inside the training recipe; use it only for post-training admission diagnostics. - Devanagari-written Limbu PP-OCRv5 training smoke: `outputs/limbu-devanagari-cdc-ppocrv5-training-smoke-2026-06-21` is a 32-train / 8-dev CPU smoke subset made from the portable training bundle with `tools/prepare_paddleocr_training_smoke.py`. It explicitly records `sealed_eval_used=false`; the bundle's `labels/eval.txt` is PaddleOCR validation naming for the dev split, not the sealed 31-row held-out eval pack. The smoke was run from scratch for one epoch under `/tmp/ocrtech-paddle311/bin/python` and `/tmp/PaddleOCR-v3.7.0`, completed 16 train iterations and 4 validation iterations, saved `best_accuracy`, `latest`, and `iter_epoch_1` checkpoints, and was audited by `tools/audit_paddleocr_training_smoke.py` with `audit_passed=true`, `issues=0`. Smoke summary SHA-256 is `998ef85358e1858c22bac5966ad00290c2e1809b5d1497d61bea38b94ebc73e7`; smoke audit SHA-256 is `811950bacfb19bcc936fc84ed89cb617a6732aaa6ef6529cef19acfac37284a6`; best checkpoint SHA-256 is `3b41eab11423fa1ac3d53bcffd1c8108f211818a9adb7257bf5de25745115535`. This is training-path readiness evidence only; it is not a quality result because it uses a tiny subset and no pretrained initialization. - Devanagari-written Limbu held-out admission recipe: `configs/eval-harness-recipes-v1.json` now contains `limbu-devanagari-cdc-ppocrv5-devclean-heldout`. It points at the dev-clean corpus 31-line eval split, uses the combined train+dev manifest only for leakage checking, and validates with no structural issues. It remains non-claim-ready until a trained checkpoint, packaged model card, reproducible prediction command, frozen pack, and reviewed or calibrated references exist. - Devanagari-written Limbu training/admission plan: `configs/limbu-devanagari-ppocrv5-admission-plan-v1.json` is the machine-checkable guardrail for the next GPU run. `tools/validate_recognizer_training_admission_plan.py` verifies the bundle hashes, expected split counts, exact train+dev manifest identity, zero train/dev/eval overlap by sample/image/text hashes, and the rule that checkpoint selection may use only train/dev while the 31-line eval split is sealed. Current validation reports `valid=True`, `training_ready=True`, and `heldout_admission_ready=0`; this means the branch is ready to train, not ready to claim or admit. - Devanagari-written Limbu PP-OCRv5 full training job: `outputs/limbu-devanagari-cdc-ppocrv5-training-job-2026-06-21` was materialized by `tools/prepare_recognizer_training_job.py` from the admission plan. It writes `recognizer-training-job.json` and an executable `run-training.sh` launcher using `/tmp/ocrtech-paddle311/bin/python` and `/tmp/PaddleOCR-v3.7.0`. The job manifest records 5,551 train rows, 258 dev rows, and the sealed 31-line eval split only as an audit artifact with `used_for_training=false`; `archive_member_hits=[]` confirms the exact sealed eval manifest/label paths are not in the training tarball. Job manifest SHA-256 is `b241f1f0bb7a9011429598fd3c92e5aaffced5a1af6bcb796a81bf5927b611d8`; launcher SHA-256 is `06a2787a34a1da197c78242c4d05c9b318322789de453af08c54f3b03be56831`. The manifest has one warning: the bundle manifest records a required passing corpus audit, but the audit JSON itself is not packaged in the archive. This is a launcher and audit guard only; no full checkpoint has been trained or admitted. - Devanagari-written Limbu PP-OCRv5 runtime pre-training preflight: `tools/preflight_recognizer_training_job.py` now extracts the materialized training bundle into an isolated audit workspace, parses the packaged PaddleOCR YAML, verifies `Global.character_dict_path` and `Global.save_model_dir`, checks every train/dev label row against extracted crop files, confirms manifest counts, rechecks sealed eval hashes and archive exclusion, and imports `paddle`/`paddleocr` with the recorded Python runtime. The real preflight at `outputs/limbu-devanagari-cdc-ppocrv5-training-runtime-preflight-2026-06-21` reports `ready_to_start_training=true`, `issues=0`, `warnings=0`, train rows `5551`, dev rows `258`, missing label images `0`, malformed label rows `0`, Python `3.11.13`, Paddle `3.3.1`, and PaddleOCR `3.7.0`. Report JSON SHA-256 is `417b8fcb177edd038fe6739a50311656ef2e2930ef8b0ec910361b8b75594289`; Markdown SHA-256 is `fdd24527d29f5576709427622f3c8b092461bb7ce2c77cc9533e971889392686`. This is still only a pre-training launch gate, not a trained model or admission. - Devanagari-written Limbu PP-OCRv5 current-host training launch: `tools/prepare_recognizer_training_runtime_launch.py` generated `outputs/limbu-devanagari-cdc-ppocrv5-training-launch-current-host-2026-06-21`. This host is CPU-only (`compiled_with_cuda=false`), so the launcher records explicit PaddleOCR overrides: `Global.use_gpu=False`, `Global.save_model_dir=training-recipes/ppocrv5-mobile-devclean/checkpoints-current-host-cpu`, `Train.loader.num_workers=0`, and `Eval.loader.num_workers=0`. The launch manifest SHA-256 is `c56e9211058ff0df87e595fd926b607057339bd96b466468779c13c3eb90d27b`; launcher script SHA-256 is `1c58b3815ae1fc3e66026c7c51d6c81948749243d93a4d64afa3607dec77e4fd`. Training is running in tmux session `limbu_devanagari_ppocrv5_training_20260621`; the latest verified progress line is `epoch: [11/20], global_step: 7000` with CPU ETA around `7:33:52`. This is an in-progress train/dev run only. After it finishes, run the completion audit with the manifest's recorded `--workspace` and `--checkpoint-dir` before exporting, packaging, or scoring sealed heldout. - Devanagari-written Limbu PP-OCRv5 training status monitor: `tools/monitor_recognizer_training_run.py` writes a structured status snapshot from the launch manifest, tmux session, live training log, and checkpoint directory. The current snapshot at `outputs/limbu-devanagari-cdc-ppocrv5-training-status-2026-06-21` reports `status=running`, `ready_for_completion_audit=false`, `issues=0`, `warnings=0`, latest progress `epoch: [11/20], global_step: 7000`, `acc=0.375`, `norm_edit_dis=0.778184`, `ips=2.44833`, ETA `7:33:52`, latest eval `acc=0.20542634862688572`, `norm_edit_dis=0.6081954332798136`, best eval `acc=0.20542634862688572`, `norm_edit_dis=0.6081954332798136` at epoch 11, and `next_action=continue_monitoring_training`. The monitor now records training-log age against a 900-second stale threshold; this snapshot has `warnings=0`. The run is still active, so it is not ready for completion audit yet. Status JSON SHA-256 is `d0c2a2bebe9a6a9d1bd5938092247e9ff968714b8708d16d49735943930f4a50`; Markdown SHA-256 is `9d991c83d98ad85934e05954a88d9761cfd6773c9c232b343456410f3ce20b8c`. Re-run this monitor until it reports `ready_for_completion_audit=true`, then run the completion audit; do not score the sealed heldout split before that. - Devanagari-written Limbu PP-OCRv5 training completion audit: `tools/audit_recognizer_training_completion.py` is the next gate after the long training job finishes. It verifies that the training workspace exists, the PaddleOCR config and dictionary resolve, the selected `best_accuracy` checkpoint is inside the train/dev workspace, and the sealed eval is still post-selection only. When green, it writes the export command, package command, sealed-eval prediction command, and a resolved held-out eval recipe using `runner.type=model_config`. The current audit at `outputs/limbu-devanagari-cdc-ppocrv5-training-completion-audit-2026-06-21` is intentionally red: `ready_for_export=false`, `issues=5`, because the training workspace/checkpoint do not exist yet. Audit JSON SHA-256 is `3fe15749a5c2a83ce9a764c8cc98f9cfe8b107b33d7eb2be728cf831346ef516`; Markdown SHA-256 is `8e9c9678a4a042a52b9803557b6ff3788b09a4eef05372a11746965354f93890`. - Generic Devanagari v2 export preflight: `outputs/limbu-devanagari-primary-candidate-deva-v2-export-preflight-2026-06-21` now records a PaddleOCR export, package, model-card audit, and CDC held-out score for `outputs/devanagari-recognizer-v2-2026-06-18/deva-v2.tgz` (archive SHA-256 `7e81660674468f99b2940224fe5ef3e7c9d062d6a05fd3cf4dabf52ac9b4e1df`). The extracted checkpoint SHA-256 is `ddea1db34e89e2c1cdde53d5364eb9156b26dbe8e0a5e67db4c26dd9c97e6676`; export recipe SHA-256 is `6e18a8cfcf8ebab247be910f9566b30327f10dcd3aef2270ec3979960f7b86c3`. `/tmp/PaddleOCR-v3.7.0` was restored at commit `b03f46425e8ff4442b268ce449e3eef758146cd4`; export required overriding the relative dictionary path and forcing CPU. The packaged line-recognition model card audits cleanly at `outputs/limbu-devanagari-primary-candidate-deva-v2-export-preflight-2026-06-21/package/model-card.json` (SHA-256 `0c41a9811484349805cd608410da3626b795c1601a7ba014c0e23bca69c0efd0`). Prediction on the 31-row CDC sealed eval split had 0 runtime failures, but the score is still terrible: codepoint CER 0.835628, grapheme CER 0.858748, exact-line accuracy 0.0, and `claim_safe=false`. The score bundle audit at `outputs/limbu-devanagari-primary-candidate-deva-v2-export-preflight-2026-06-21/score-cdc-heldout-audit` passes with zero issues and `claim_safe=false` (SHA-256 `8a538059a0320902196b3a1125edd97b34f21cb9afb4f32826f24c4c08135edf`). Treat `deva-v2` as a failed generic baseline, not a Devanagari-written Limbu primary. - Sikkim Herald Sirijonga crop: `outputs/limbu-dual-script-real-run-2026-06-21/sikkim-sirijonga-crop-ocr-v4-guarded`. Capture audit and output audit pass. The updated auto line-recognition path now emits Sirijonga Unicode and classifies the line as `limbu_sirijonga`, but the line still remains in the review queue: confidence is 0.797, and the diagnostic codepoint CER against `data/sikkim-herald/limbu/_evalpack_demo/line_crop_demo.gt.txt` is about 0.095. This improves over the earlier deployed component's roughly 0.302 diagnostic CER, but it is still a single demo crop, not claim-grade scoring. - Sikkim Herald Sirijonga page: `outputs/limbu-dual-script-real-run-2026-06-21/sikkim-sirijonga-page-ocr-v4-guarded`. Capture audit and output audit pass. The full-page path emits 22 lines; 20 enter review, average confidence is 0.635, and quality fails at 0.619. The guard protected one Devanagari-looking primary line, but the page remains low quality. This is useful page-level operational evidence, not a success claim. - Sikkim Herald Sirijonga page draft eval: `outputs/limbu-page-eval-drafts/sikkim-sirijonga-2020-12-03-page1-v1`. The draft reference was built from the PDF text layer with the Sikkim Herald Limbu legacy-font converter and scaled to the prepared page image. It has 86 machine-converted Sirijonga reference lines and is explicitly not claim evidence (`gt_status=machine_converted_unreviewed`, `claim_evidence_eligible=false`). Scoring the guarded live-detector OCR output against this draft as `--ocr-output-kind live_detector` gives codepoint CER 0.891560, grapheme CER 0.897412, line detection F1 0.018519, and only 1 matched line out of 86 references. The score audit passes artifact consistency but remains `claim_safe=false`, as it should. A second diagnostic materialized the same 86 PDF-derived reference boxes as line crops, forced the v4 Sirijonga component into recognizer-only `recognition_mode=line`, and scored the resulting document as `--ocr-output-kind oracle_line_boxes` at `outputs/limbu-page-eval-drafts/sikkim-sirijonga-2020-12-03-page1-v1/score-oracle-line-boxes-v4`. That oracle-box run has 86/86 matched lines, line detection F1 1.0, codepoint CER 0.274289, and grapheme CER 0.548983. The paired comparison at `outputs/limbu-page-eval-drafts/sikkim-sirijonga-2020-12-03-page1-v1/compare-oracle-vs-live-v4` shows a non-claim-safe codepoint-CER improvement of 0.617272 over the live detector. This proves detection/layout is a major failure, but the remaining oracle-box CER is still too high; the Sikkim Herald register and/or the draft machine-converted reference also need recognizer and label-quality work. A third diagnostic at `outputs/limbu-page-eval-drafts/sikkim-sirijonga-2020-12-03-page1-v1/image-line-box-documents-v4` uses `tools/materialize_page_image_line_boxes.py`: it detects line-like components from image pixels using Otsu thresholding and morphology, computes final boxes from ink pixels, gives the recognizer 12 px of crop margin, and forces the v4 recognizer to `recognition_mode=line`. Scored as a live detector at `score-image-line-detector-v4`, it emits 125 lines, matches 59/86 references, reaches line detection F1 0.559242, codepoint CER 0.460255, and grapheme CER 0.576710. That is materially better than the current Paddle live detector but still well short of oracle boxes. A detector-only reading-order comparison at `outputs/limbu-page-eval-drafts/sikkim-sirijonga-2020-12-03-page1-v1/compare-detector-reading-order-column-major-v1` compares `top_to_bottom` and `column_major` with the same detector settings; both modes score matched-line reading-order pair accuracy 0.992402. A bounded detector parameter sweep at `outputs/limbu-page-eval-drafts/sikkim-sirijonga-2020-12-03-page1-v1/detector-param-sweep-v1` evaluated 900 morphology configs and did not improve on the current detector family: best line F1 remains 0.559242 with 125 predictions for 86 references and 59 matches. Keep this as a detector prototype, not the production default: the Sikkim blocker is overprediction, missed/merged lines, recognizer register quality, and reference verification, not a simple morphology parameter or column-major ordering switch. The interpretation is blunt: the router is now closer to the required two-script shape, and the v4 recognizer materially improves a real Sirijonga line crop, but full-page Sirijonga quality is still poor. We now have multiple Sirijonga/Namdhinggo page diagnostics, a Devanagari-written Limbu synthetic smoke pack, and a real CDC Devanagari-written Limbu text-only page draft. The Devanagari side is no longer blocked on source discovery, but the current Tesseract primary fails badly on that real CDC draft. It is still not claim-grade until the CDC pages get reviewed text, image line boxes, enough held-out pages, and a Devanagari-written Limbu recognizer or OCR primary that works on this register. ## Next Engineering Target Do not spend more effort polishing generic audit scaffolding before measuring the core failure. The next useful milestone is a tiny frozen two-script page eval pack and a detector-vs-recognizer diagnostic: - keep `configs/eval-target-coverage-v1.json` as the top-level claim coverage gate. Its `limbu-first-two-script-ocr` target set must show both `limbu/Limbu` and `limbu/Devanagari` as coverage-ready before any two-script Limbu OCR claim. This target set requires both recognizer eval recipes and full page-level eval recipes, so recognizer-only readiness cannot satisfy the page-capture goal. - promote at least one Sirijonga page reference from machine-converted draft to reviewed status, and promote the CDC Devanagari draft from text-only reference to reviewed page reference with source image hashes, source document/page/bbox provenance, GT trust status, claim eligibility, and line-level image boxes. The existing Devanagari smoke pack is useful for harness regression only; the CDC pack is the real-page draft, but it is not a substitute for reviewed line-bbox evidence. Use `tools/inventory_limbu_page_sources.py --require-real-devanagari-page` as the source-readiness gate before claiming new Devanagari sources exist - score the same pages twice: once with live detector boxes from `parse-limbu-doc`, and once with oracle/PDF-derived line boxes passed to the recognizers; record these scorer runs as `--ocr-output-kind live_detector` and `--ocr-output-kind oracle_line_boxes` - if oracle boxes recover the line-crop-level quality while live detector boxes fail, prioritize a Sirijonga-capable text detector and reading-order path; that is the oracle-quality Gorkhapatra finding. If live-detected boxes have good geometry but high matched-line CER, as the current tuned Gorkhapatra morphology detector does, improve crop tightness, crop padding, line splitting/merging, and line-recognizer robustness before celebrating detector F1. If matched-line reading-order accuracy is materially below oracle, improve column/article ordering from aligned-line evidence rather than relying on raw reading-order IDs. `tools/materialize_page_image_line_boxes.py` now exposes `--reading-order column_major` and `--reading-order auto_layout` as explicit diagnostics alongside the default `top_to_bottom`. `auto_layout` records the requested mode, selected mode, and layout features in each materialized document. `tools/compare_limbu_sirijonga_detector_reading_order.py` now provides a recognizer-free way to compare those modes against reference line boxes; current Gorkhapatra and Sikkim runs show zero delta for `column_major`, while `auto_layout` recovers the Gorkhapatra wide-RTL ordering gain without flipping Sikkim. Keep this as measured layout selection, not claim-grade OCR quality. `tools/sweep_limbu_sirijonga_detector_params.py` ranks detector-only morphology configs before recognizer runs; the current sweep finds a minor Gorkhapatra precision improvement and no Sikkim improvement. If oracle boxes remain high-CER as they do on the current Sikkim draft, split work between detector improvement, same-register recognizer data, and reference verification - calibrate the Devanagari primary guard and review thresholds against page CER instead of treating Tesseract confidence or script ratios as evidence. The current CDC diagnostic shows this calibration cannot be a threshold tweak only: `nep+eng` Tesseract is around 0.898 codepoint CER on the real Devanagari draft, so a stronger Devanagari-written Limbu recognizer/data path is required ## Outputs Each run writes the normal parser outputs: - `document.json` - `document.md` - `quality.json` - `tables/` - `figures/` The Limbu wrapper also writes: - `limbu-capture-prep.json`: raw/prepared image paths, hashes, cleanup operations, source/prepared image-quality metrics, timestamp, and run context - `limbu-capture-audit.json` / `.md`: verification that the raw copy, prepared image, recorded hashes, decodable image bytes, image-quality metrics, and capture operation metadata are still consistent - `capture-prep-audit/limbu-capture-audit.json` / `.md`: the capture audit copied into an OCR output bundle when `--capture-prep-metadata` is used - `limbu-pipeline-audit.json`: run-level line counts, script counts, thresholds, and claim scope - `limbu-line-audit.jsonl`: one row per OCR line with Sirijonga/Devanagari ratios and review flags - `limbu-post-correction-audit.json`: deterministic Limbu post-correction status, profile id/path/hash, rule count, changed count, and claim scope - `limbu-post-correction-lines.jsonl`: one row per OCR line with original text, corrected text, applied rule ids, and changed flag - `limbu-review-queue.tsv`: only lines that need human review - `limbu-review-dashboard.html`: a static review dashboard that pairs each queued line with its crop, script class, confidence, review reasons, OCR text, and TSV correction row - `line-crops/manifest.jsonl` and `line-crops/summary.json`: one crop-lineage row per OCR line, with crop paths/hashes when the source page is croppable - `limbu-correction-audit.json`: accepted review corrections applied to a corrected document - `limbu-correction-pairs.jsonl`: noisy/clean line pairs for future Limbu-specific corrector training - `limbu-output-manifest.json`: run context, input provenance, and paths, sizes, and SHA-256 hashes for emitted artifacts - `limbu-output-audit.json` / `.md`: verification that the output manifest, artifact hashes, counts, and stage-specific audits are still consistent Lines enter the review queue when confidence is missing, confidence is below the chosen effective threshold, the line mixes Devanagari and Sirijonga, or the output contains neither script. `parse-limbu-doc` keeps the global `--low-confidence-threshold` default but can override it per script with `--sirijonga-low-confidence-threshold`, `--devanagari-low-confidence-threshold`, `--mixed-script-low-confidence-threshold`, and `--other-script-low-confidence-threshold`. These threshold inputs, plus `script_ratio_threshold`, are validated as finite ratios in `[0, 1]` before OCR artifacts are emitted, so booleans, `NaN`, and out-of-range values cannot silently alter review routing or script classification. The audit replay validates the embedded `limbu-pipeline-audit.json` thresholds again before using them, so a refreshed manifest hash cannot legitimize invalid script-classification policy. `limbu-line-audit.jsonl`, `limbu-review-queue.tsv`, and `limbu-review-dashboard.html` record the effective review threshold for each queued line so script-specific triage is replayable. The review TSV is intentionally simple so corrections can become future calibration or post-correction training data; `limbu-review-dashboard.html` is the human-facing contact sheet for those same rows and is included in the manifest hash contract. `audit-limbu-output` replays line triage from `document.json`: it recomputes script class, effective review threshold, review reasons, `needs_review`, script counts, and review-line count, then fails if `limbu-line-audit.jsonl`, `limbu-review-queue.tsv`, or `limbu-pipeline-audit.json` drift from the document. Review queue replay includes the queued confidence, so a low-confidence line cannot be silently presented to reviewers as high-confidence text. For operational digitization runs, `audit-limbu-output` also has opt-in strict policy gates: `--require-capture-prep` requires a passing capture-prep audit to be bound into the OCR output and replays the current capture-prep metadata/artifact hashes from disk, the `--min-capture-prepared-*` flags forward prepared-image quality thresholds into that capture replay and fail low-resolution, low-texture, or low-contrast prepared images. Those capture-threshold policy inputs are validated as finite non-negative numbers before audit work starts, so invalid thresholds fail as configuration errors, `--require-no-pending-review` fails OCR outputs that still have review lines or correction outputs with skipped review rows, and repeated `--require-script` flags require observed line counts for specific script classes such as `limbu_sirijonga` and `devanagari_limbu`. Required script names are normalized and validated against the fixed Limbu script-class vocabulary before audit work starts, and boolean count values are rejected instead of being treated as `1`, so misspelled or ambiguous policy inputs fail as configuration errors instead of becoming ordinary missing-script output failures. For stricter acceptance, `--require-script-count SCRIPT=COUNT` requires a minimum observed line count for a script class, so a token-level accident or one-line smoke cannot satisfy a real two-script coverage policy. `--min-line-count`, `--min-average-line-confidence`, and `--min-quality-score` add explicit output-volume and quality gates using the audited `document.json` quality metadata, and `--min-line-count` rejects boolean API values, so a nearly empty or low-confidence output cannot pass strict acceptance only because provenance and script classes are present. These flags are intentionally not defaults: development and diagnostic bundles can still be audited for artifact integrity, while real page digitization can demand capture provenance, prepared-image quality, zero unresolved review rows, enough text volume, minimum quality, and the expected script coverage. For capture-prep bundles themselves, use `audit-limbu-capture --require-metadata-path-self` so copied or renamed metadata cannot quietly stand in for the recorded `metadata_path`; for full OCR output bundles, use `audit-limbu-output --require-capture-metadata-path-self` to enforce the same check during capture replay. A fresh two-script smoke at `outputs/limbu-strict-output-policy-smoke-2026-06-21` passed the strict policy with `require_capture_prep=true`, `require_no_pending_review=true`, and required scripts `limbu_sirijonga` plus `devanagari_limbu`; strict audit JSON SHA-256 is `2fc71f191ba581d58f59480b54695a9297778f3c54a2a63c8a7da339d618142e`. Only rows whose `review_status` is accepted by `apply-limbu-review-corrections` are applied; duplicate accepted targets and accepted rows with empty `corrected_text` fail explicitly. Accepted review rows also use the same constrained `script_class` vocabulary as correction-pair packs and post-correction profiles; explicit typos fail in both the writer and the audit replay path. For `review_correction` bundles, `audit-limbu-output` now replays the accepted TSV rows from the original `document_path` and `review_queue_path` recorded in `limbu-correction-audit.json`, verifies their SHA-256 hashes, binds manifest `provenance.input_document` and `provenance.review_queue` to those same paths/hashes, recomputes applied, changed, and skipped counts using the source OCR document's recorded `script_ratio_threshold`, then compares the replayed document text and `limbu-correction-pairs.jsonl` rows against the emitted corrected bundle. It also replays the corrected line's embedded `metadata.limbu_pipeline` review flags and `post_correction` reviewer/status/original/corrected-text metadata. This means a corrected `document.json`, embedded correction story, or training-pair JSONL cannot be trusted just because the files exist or the counts match; they must be reproducible from the source OCR document and the reviewed queue. For claim-grade corrected bundles, add `--require-reviewer-for-corrections`; this strict policy fails accepted correction rows whose reviewer field is blank while still allowing quick non-claim experiments to run without reviewer metadata. ## Post-Correction Boundary The current automatic post-correction lane is deliberately deterministic. If `--post-correction-profile` is supplied, the profile must be a Limbu JSON object with a `profile_id`, `language=limbu`, `script_scope`, and exact/token rules whose replacements contain Limbu or Devanagari text. Rule IDs must be unique. `script_scope` and rule-level `script_class` values must be one of `limbu_sirijonga`, `devanagari_limbu`, `mixed_limbu_devanagari`, or `other`; typo aliases such as `sirijonga` are rejected instead of silently disabling a rule. The profile is applied before review export, and every line records original text, corrected text, applied rule ids, profile hash, profile admission status, and changed status. With no profile, the same artifacts are still written with `status=not_configured`, so missing automatic correction is visible. Profile admission is intentionally separate from profile shape. A profile with no `admission` object can run, but it is marked `experimental` and `audit-limbu-output` warns that automatic corrections are not claim-ready. A profile that claims `admission.status=validated` must record a hashed eval artifact, frozen eval-pack identifier, metric name, and before/after metric values where `after <= before`; otherwise `parse-limbu-doc` fails instead of applying the profile. This keeps language-specific post-correction useful for triage without letting it become an unverified accuracy claim. The human-reviewed correction lane remains separate. That is intentional: prior generic text-corrector experiments made OCR substantially worse, so any learned Limbu corrector should be trained only from reviewed Limbu correction pairs and admitted through the same held-out eval discipline as recognizers. The corrected document records the original OCR text, corrected text, reviewer/status, review TSV hash, and `post_correction.status=human_review_applied` on each changed line; it also records the source OCR document's `script_ratio_threshold` so inferred correction-pair script classes use the same script policy as the reviewed OCR output. Output audit now replays those embedded fields against the source document and accepted review TSV. `build-limbu-correction-pair-pack` canonicalizes accepted noisy/clean pairs into a frozen train/heldout correction pack with source pair-file hashes, deterministic SHA-256 split selection, a pack-content digest, and `claim_eligible=false` rows. The heldout split is the input for post-correction profile scoring; the pack is calibration evidence, not page OCR ground truth. `audit-limbu-correction-pair-pack` independently replays that pack: it checks the summary artifact, train/heldout file hashes, row counts, split labels, duplicate sample IDs, row text shape, source pair-file hashes when available, and the canonical `pack_content_sha256`. Run it before using the train split for profile derivation or the heldout split for admission scoring. `derive-limbu-post-correction-profile` converts accepted `limbu-correction-pairs.jsonl` rows into exact-match deterministic rules only after normalizing the noisy/clean text, dropping unchanged rows, hashing every source pairs file, enforcing minimum support, and rejecting conflicting mappings from the same noisy text to multiple clean texts. The generated profile is still marked `admission.status=experimental`; it is useful for repeatable triage, not claim-ready automatic correction, until a frozen held-out post-correction eval is attached and passes `audit-limbu-post-correction-profile`. `score-limbu-post-correction-profile` applies the same profile loader and rule engine used by runtime OCR to held-out noisy/clean pairs. It writes `limbu-post-correction-profile-eval.json`, `limbu-post-correction-profile-eval-lines.jsonl`, and Markdown, reporting `text_cer_codepoint_micro` before and after correction, changed/improved/regressed row counts, source pair-file hashes, profile hash, and the eval JSON SHA-256 printed by the CLI. The score fails if aggregate codepoint CER regresses or if any held-out row gets worse. A profile can only claim `admission.status=validated` after that eval JSON hash is copied into `admission.eval_run_sha256` with the frozen eval-pack identifier and non-regressing before/after values. `admit-limbu-post-correction-profile` performs that admission copy under guard. It refuses failed evals, eval/profile SHA mismatches, missing frozen eval-pack identifiers, non-numeric metrics, aggregate regressions, and any regressed held-out row. It writes a new `limbu-post-correction-profile-admitted.json`, an admission report, and an audit directory; the source profile is not mutated in place. Both OCR and correction stages write `limbu-output-manifest.json`, so a reviewer can verify exactly which artifacts were produced by that stage and whether any expected artifact is missing. OCR manifests also hash the model card, fallback model card, capture-prep metadata, and post-correction profile when supplied; review-correction manifests hash the source document and review TSV. `audit-limbu-output` recomputes those provenance hashes, replays manifest `source_path` / `source_sha256` and binds the source path fields to `document.json.source_path`, checks OCR capture-prep/profile provenance against `limbu-pipeline-audit.json` and `limbu-post-correction-audit.json`, and, for review-correction bundles, checks that the manifest points to the same source document and review TSV recorded in `limbu-correction-audit.json`, so changed or substituted capture/model/profile/review inputs make the bundle fail audit. It also enforces the fixed required artifact set for OCR and review-correction stages; removing a required artifact from `limbu-output-manifest.json` is itself an audit failure, even if the file still exists on disk. `audit-limbu-output` recomputes artifact hashes, validates document counts against the manifest, checks OCR line/post-correction/review/crop counts, verifies capture-prep audit status when present, reruns the capture-prep audit into `capture-prep-replay-audit/`, verifies post-correction profile hashes and crop hashes when they exist, replays image-line crop manifests against `image-line-ocr-run.json` and the current crop PNG hashes, checks kept image-line crop rows against `document.json` line ids, bboxes, text, confidence, and embedded crop provenance, checks image-line run metadata against the current source image and the duplicated document/page metadata, binds image-line model config metadata to `limbu-output-manifest.json` provenance path/hash, replays image-line detector source-pass count summaries when present, checks that review queue triage fields, including confidence, still match the `needs_review` rows in `limbu-line-audit.jsonl`, replays each `document.json` line's embedded `metadata.limbu_pipeline` script ratios, script class, review flag, review reasons, and effective review threshold from the current line text/confidence after validating the embedded replay thresholds, replays embedded `post_correction` metadata from `limbu-post-correction-lines.jsonl` and `limbu-post-correction-audit.json`, and checks that the review dashboard card count, displayed line metadata, displayed confidence, displayed OCR text, TSV copy row, and crop link still match the review queue and crop manifest. For corrected bundles, it then replays the review-correction audit from the original source document and review queue, verifies the recorded input hashes, and checks corrected document text plus noisy/clean correction pairs against that replay. When strict policy flags are used, the generated `limbu-output-audit.json` records the policy object beside the pass/fail result so later reviewers can tell whether an output was merely artifact-consistent or operationally acceptable for the intended capture and script scope. ## Capture And Cleanup Requirements The capture source should preserve page detail before OCR: - use full-page still images as the OCR input contract - if moving-camera material exists upstream, convert it outside this pipeline into sharp still page images before capture cleanup - deskew and perspective-rectify before line recognition - keep the raw still image, rectified page, line crops, OCR JSON, and review TSV together - never overwrite a raw capture with a cleaned image The current capture command preserves the raw image, applies EXIF transpose, optional manual crop, optional automatic four-corner page detection, optional manual four-corner perspective rectification, optional automatic text deskew, optional manual rotation, grayscale conversion, and autocontrast. `--auto-detect-page` searches for a large convex page contour and records the detected quad plus area ratio before rectification. `--auto-deskew` first uses OpenCV near-horizontal line evidence to estimate skew after crop/perspective cleanup, then falls back to row-projection scoring over text ink so fragmented glyph rows can still be deskewed. It records either the detected/applied angle or a skipped status when the page does not contain enough evidence; use `--max-auto-deskew-degrees` to cap automatic rotation. `--perspective-quad` uses corners in this order: top-left, top-right, bottom-right, bottom-left, measured after EXIF transpose and after the optional crop. It does not implement moving-frame selection; that is outside this OCR pipeline's input contract. `limbu-capture-prep.json` records the operation sequence, raw and prepared hashes, source/prepared image-quality metrics including size, luminance spread, edge spread, and entropy, timestamp, and command/runtime context when run through the CLI. `audit-limbu-capture` verifies the raw copy and prepared image hashes, validates capture operation metadata, checks existing capture artifacts are decodable images, replays recorded quality metrics for available images, fails stale or missing prepared artifacts, and only warns if the original source path has moved after the raw copy was preserved. For frame-extracted stills or field captures, pass opt-in quality gates such as `--min-prepared-width`, `--min-prepared-height`, `--min-prepared-entropy`, `--min-prepared-luminance-stddev`, and `--min-prepared-edge-stddev`; the audit records the chosen `quality_policy` and fails prepared images below those thresholds. When `parse-limbu-doc` receives a croppable prepared page image, it also writes tight line crops under `line-crops/` using the OCR bboxes; non-croppable sources still get a line-crop manifest with warnings so missing crop lineage is visible. ## Claim Boundary This pipeline is operational evidence. It is not enough for a paper claim unless the same outputs are scored against frozen page references with source-image hashes, page/line provenance, ground-truth trust labels, script inventory coverage, leakage checks, confidence intervals, and worst-page review artifacts. The current real-page diagnostic baseline is `outputs/limbu-measured-page-baseline-2026-06-22/README.md`. Treat it as engineering evidence only, not a public result: the references are unreviewed or machine-converted, the packs are not frozen/claim-eligible, and current audits are not clean under the latest stricter page-audit rules. The important signal is accuracy direction: Devanagari CDC pages need the active PP-OCRv5 recognizer before the result is meaningful, while Sirijanga Gorkhapatra/Sikkim pages are dominated by detector/layout misses before recognition quality. The current Devanagari page-marker-v2 candidate is now registered in the eval harness as `limbu-devanagari-cdc-page-marker-v2-champion-coverage-gated`, and the `limbu-first-two-script-ocr` coverage target points the Devanagari page-eval slot at it. That is not a readiness claim. The latest validators report `recipes=12 valid=True claim_ready=0` and `valid=True coverage_ready=False target_sets=3 gaps=50`; the top-level two-script set still has 6 gaps across Sirijonga/Limbu and Devanagari normalization, recognizer, and page recipes. The Devanagari slot is operationally registered but blocked by 3-page draft scope, 0 claim-ready references, unreviewed GT, unfrozen rows, missing hash-verifiable model artifacts, `claim_safe=false`, and unresolved review rows. The Sirijonga page recipe is now reproducible as a sidecar replay through `tools/copy_page_ocr_document.py`; it replays the current operational `conf070` page-document bundle into `run_eval_recipe.py` and records hashes. The smoke run at `outputs/eval-recipe-smoke-limbu-sirijonga-gorkhapatra-page-current-router/` passes audit but stays `claim_safe=false`: 1 machine-converted unreviewed page, 0 claim-eligible rows, codepoint CER `0.739361`, line F1 `0.872458`, and matched-line CER `0.046585`. This removes a harness reproducibility blocker, not the underlying OCR quality or data-readiness blockers. The current selected Sirijonga diagnostics now have review packets for unresolved page regions: `outputs/limbu-sirijonga-page-unresolved-review-2026-06-22/`. Gorkhapatra `conf070` contributes 69 textless review crops, mostly center-column missed lines; Sikkim same-row merge contributes 22 textless review crops, split between missed lines and extra predictions. Both packet audits pass with 0 hidden-reference leaks. Use these packets as the next layout/recovery substrate before another detector sweep. The packets now include a blank `corrected_text` review field, and `tools/apply_unresolved_page_review_packet.py` applies reviewed rows back to scoreable page-document projections. Pending rows are no-ops; accepted/corrected missed-reference rows require non-empty `corrected_text`; accepted/corrected unmatched predictions update the existing line only when `corrected_text` is supplied; false positives are deleted only with explicit `drop`/`delete` statuses. Pending application smokes exist for both Sirijonga diagnostics and score identically to the source outputs: `gorkhapatra-operational-conf070-review-application-pending` at codepoint CER `0.739361` and `sikkim-same-row-merge-review-application-pending` at codepoint CER `0.418057`. `tools/audit_unresolved_page_review_coverage.py` independently verifies that these packets cover every current unmatched alignment row without writing hidden reference text: Gorkhapatra covers 67/67 missed references and 2/2 extra predictions; Sikkim covers 9/9 missed references and 13/13 extra predictions. The strongest current Gorkhapatra Sirijonga recovery evidence comes from the rejected auto-split-tall branch, but only as a review source. The selected `conf070` documents compared against auto-split-tall yielded 100 candidate-only page rows with a passing packet audit. Oracle/reference-overlap analysis shows 49 of those rows correspond to the 67 currently missed references, and applying their candidate OCR text through `tools/apply_candidate_page_line_reviews.py` raises line F1 to `0.964346` with precision `0.993007` and recall `0.937294`. That is not a usable text-output win: page codepoint CER worsens to `0.766779` from selected `conf070`'s `0.739361`, and grapheme CER worsens to `0.798907`. The operational action is therefore to keep auto-split-tall rows in the non-oracle prioritized review queue at `outputs/limbu-sirijonga-page-unresolved-review-2026-06-22/gorkhapatra-auto-split-tall-prioritized-candidate-line-review/` (100 body-line candidates, 99 high priority, audit passed), then accept reviewed transcriptions or improve recognition on those crops before insertion. Do not make auto-split-tall candidate text the default book OCR output. The corresponding non-oracle crop probe at `outputs/limbu-sirijonga-page-unresolved-review-2026-06-22/gorkhapatra-auto-split-tall-candidate-line-text-crop-probe/` processed all 100 body-line candidates and refined 44 by trimming top bleed from multi-row crops. Use it for targeted Sirijonga recognizer/reviewer work; it is not an application result. Running the packaged v4 Sirijonga recognizer over those original/refined crops exposed and fixed a harness issue: recognizer predictions can contain multiple text lines, so `tools/predict_recognizer_eval.py` now flattens embedded newlines/tabs before writing TSV. The refined-crop recognizer comparison changed 40/100 predictions and reached max confidence `0.992109`, but remains `automatic_application_safe=false`. A strict machine selector (`0.90` confidence, `0.05` confidence delta) slightly improves page codepoint CER to `0.737090`, but lowers line F1 to `0.866545` and increases extras to 7. That is not acceptable as the default book OCR policy; it is a candidate source for reviewed insertion or a better crop recognizer. `tools/audit_candidate_page_line_application_effect.py` now enforces that distinction for page-candidate insertions. The strict recognizer-probe application is rejected as `book_ocr_objective_safe=false`: 6 inserted rows, only 1 match, 5 extras, and the one matched inserted line has codepoint CER `0.888889`. For this product, a CER-only gain with worse line preservation is a failed candidate. The safe oracle-feature diagnostic for those 100 candidates is `outputs/limbu-sirijonga-page-unresolved-review-2026-06-22/gorkhapatra-auto-split-tall-oracle-feature-analysis/` (report / TSV SHA-256 `4c45a640338b6510b63bced5b903b847e4725ab87f544fb36ba7def7ac2e2bb0` / `21e31ff240b2a40220b70b9f029237064b83c951509b6bea62ec9fc4855098bf`). It confirms the deployable signal is not refined recognizer confidence: selected rows average much lower refined confidence than rejected rows (`0.382649` versus `0.601181`), and the strict `0.90` / `0.05` selector finds only 1 oracle-selected row out of 6. The useful rows are instead longer and wider body-line candidates. Any future automatic Sirijonga candidate insertion should therefore be a geometry/text-feature selector, not another confidence-only threshold, and it must pass the page-level effect audit. The first geometry/text selector pass confirms the boundary. `tools/select_candidate_line_reviews_by_geometry_text_features.py` with `min_candidate_text_length=30`, `min_bbox_width=80`, and y-band `middle,bottom_or_right` selects 31 rows; oracle-overlap diagnosis marks all 31 as useful missing-line candidates. Applying their machine text improves line F1 to `0.933566` and recall to `0.881188` with no new extras, but page codepoint CER worsens to `0.761733` and reading-order accuracy drops to `0.604292`, so the effect audit rejects it. A looser `min_candidate_text_length=10` setting selects 38 rows, finds 35 useful candidates, adds 3 extras, and also fails. This is now a review/crop-target worklist, not a promotion candidate. Candidate insertion now supports explicit ordering strategies in `tools/apply_candidate_page_line_reviews.py`. The old `geometry` mode is retained for reproducibility, but it globally sorts by raw page/y/x and is poor for wide-column Gorkhapatra. `preserve_source_append` preserves the selected source order and appends reviewed candidate lines; on the 31-row precision selector it keeps all inserted rows matched and raises reading-order accuracy from the geometry diagnostic's `0.604292` to `0.750472`, though it still fails because candidate text worsens page CER. A `source_reading_order` re-sort with `wide_column_right_to_left` was also tested and is worse on this application. The 31 precision-first rows have a pending transcription worklist at `outputs/limbu-sirijonga-page-unresolved-review-2026-06-22/gorkhapatra-auto-split-tall-geometry-text-selection-len30-w80-y-midbot-transcription-worklist/`; it has JSONL/TSV/HTML/labels, blank `corrected_text`, no reference fields, and 31/31 resolving crop links. `tools/audit_candidate_line_transcription_worklist.py` verifies that worklist before review; the current audit passes with 31 pending rows, 0 crop hash mismatches, 0 forbidden fields, and 0 issues. The reviewed-worklist application bridge is now available as `tools/apply_candidate_line_transcription_worklist.py`. It compiles accepted/corrected worklist rows into candidate-page application JSONL only when `corrected_text` is non-empty, the reviewer is not machine/oracle/auto, and crop hashes validate. The current 31-row worklist is pending-only, so its pending compile accepts 0 rows and the downstream candidate-page application inserts 0 rows; the scored output remains identical to selected `conf070` (`0.739361` codepoint CER, line F1 `0.872458`). This is the mechanical path for real reviewed text; it deliberately does not apply pending machine suggestions. A diagnostic-only oracle ceiling now prevents a bad next step. The helper `tools/select_candidate_line_reviews_by_oracle_subset.py` joins the 31 geometry/text worklist rows to the oracle/reference-overlap selected rows, producing an unsafe reference-text ceiling artifact with 31 selected and 0 rejected rows. Even with perfect reference text, the 31 insertions are not a book-OCR win under append or raw geometry: line F1 improves to `0.933566` and misses drop to 36, but page codepoint CER worsens to `0.771993` with `preserve_source_append` and `0.771825` with raw geometry ordering, versus selected `conf070` at `0.739361`. The new `candidate_document_order` mode is the promising direction: it uses candidate-document line order and bbox-IoU mapping, bringing codepoint CER to `0.739024`, line F1 to `0.933566`, misses to 36, extras to 2, and reading-order accuracy to `0.775506`. It is still not admissible because grapheme CER worsens to `0.778367`. Reviewed transcription is useful only if paired with this slotting mode and grapheme-level normalization/text repair. The non-oracle machine-text version under `candidate_document_order` confirms that ordering alone is not enough: line F1 and reading order match the oracle-ceiling surface, but page codepoint CER is `0.763078` and grapheme CER is `0.797416`. Do not apply machine candidate text; use the 31-row worklist for corrected text or a better crop recognizer, then insert with candidate-document order. Further ablation says this is not just a bad subset choice. No reference-span group or single row among the 31 improves both page codepoint and page grapheme CER under candidate-document order. However, an oracle reference-order ceiling over the same exact 31 rows drops page codepoint CER to `0.102355` and grapheme CER to `0.136823` with line F1 `0.933566` and 0 effect-audit issues. The product path is therefore layout/reading-order learning for full page assembly, not more detector thresholding. `tools/analyze_page_reading_order_geometry.py` now turns that oracle order into a 21-chunk geometry target, showing that the missing deployable policy is article/block ordering rather than a single column-major sort. `tools/apply_page_reading_order_geometry_profile.py` is the current bridge from that diagnostic target to an operationalizable mechanism: it applies a chunk profile to a page-document projection and reorders lines by assigned profile chunk. With the oracle-derived 21-chunk profile, the 31-row oracle-text projection scores codepoint CER `0.095711` and grapheme CER `0.129700`; the same profile applied to non-oracle machine candidate text scores codepoint CER `0.143146`, grapheme CER `0.198112`, line F1 `0.933566`, recall `0.881188`, misses 36, extras 2, and reading-order accuracy `1.0`. The effect audit passes, but this is still not claim-safe or deployable because the profile itself came from hidden eval alignment. The next real work is replacing that oracle-derived profile with a reviewed/calibrated layout profile derived from page images, templates, or observable article/block structure. `tools/build_page_reading_order_geometry_profile.py` now provides that replacement path for geometry review: it consumes geometry-only line-box application references, rejects transcription text by default, requires explicit `--allow-pending` for seed packets, and requires explicit `--allow-multi-source-profile` before mixing layouts. On the current pending Sirijonga line-box packet, applying the packet as seed geometry produces 2 samples and 389 line boxes. The separate pending Gorkhapatra seed profile has 303 lines, 26 chunks, 25 jumps, and `profile_claim_safe=false`; when applied to the same 31-row machine-text candidate projection it scores exactly like the oracle-derived profile-order machine run: codepoint CER `0.143146`, grapheme CER `0.198112`, line F1 `0.933566`, recall `0.881188`, misses 36, extras 2, and reading-order accuracy `1.0`. This is important directionally but not operationally safe yet: the rows are still pending, so the next required work is to complete the geometry review and rebuild the profile without `--allow-pending`. Use `tools/audit_page_reading_order_geometry_profile.py --require-claim-safe` before promotion, and apply profiles in operational runs with `tools/apply_page_reading_order_geometry_profile.py --require-profile-claim-safe`. The current pending Gorkhapatra seed profile passes structural audit but fails required-safe audit and is refused by the applier under that flag. This prevents hidden-alignment or pending-review profiles from leaking into selected book OCR. `tools/admit_page_reading_order_profile_application.py` is the final promotion gate for profile-ordered page projections: it requires a safe profile audit, a profile application report using the same profile hash, and a safe page objective effect audit. On the current pending Gorkhapatra seed-profile projection, admission correctly rejects the run despite the strong score because provenance is not safe (`admitted_operational=false`, admission SHA-256 `02bcd20dc1a5598f92b9a251dd5ae4669171ba8d9429df4eb9c06cf33bc354b6`). For multi-page books, use `--profile-map` rather than one global `--profile`. The current pending seed map at `outputs/limbu-sirijonga-line-box-review-packet-2026-06-21-pending-seed-profile-map.json` maps Gorkhapatra and Sikkim pages to separate profiles. A map-driven Gorkhapatra diagnostic reproduces the same metrics as the single-profile run while recording the selected profile in `profile_usage`; admission still rejects it because the profile is pending. `tools/audit_page_reading_order_profile_map.py` audits map coverage and profile-audit linkage; the current map passes structural audit but fails required-safe audit because the mapped profiles are pending. This is the safe shape for future multi-page reviewed layouts: profile map -> profile-map audit -> required-safe application -> effect audit -> admission. `tools/parse_limbu_book_pages.py` can now apply that profile map inside the book run with `--reading-order-profile-map`. It applies the map after optional line assembly and before `book.md`, `book.body.md`, review queues, and `score-documents/` are written, so editable text and scoring use the same reordered document projection. Operational runs can add `--require-reading-order-profile-safe` and `--require-reading-order-profile-map-safe` to refuse unsafe profiles/maps. The book wrapper now also treats a map audit as evidence for one exact map: supplied audits must record the current map SHA-256, and `--require-reading-order-profile-map-safe` fails if no `--reading-order-profile-map-audit` is supplied. `tools/audit_limbu_book_output.py` now checks the profile-map hash, profile application report, assignments JSONL, optional map audit, and per-page profile source documents, so stale profile-order artifacts fail the normal book bundle audit.