WAIT — Mixed signals — read the receipts

• Last commit 1w ago
• 12 active contributors
• Distributed ownership (top contributor 43% of recent commits)
• GPL-2.0 licensed
• Tests present
• ⚠ GPL-2.0 is copyleft — check downstream compatibility
• ⚠ No CI workflows detected
• ⚠ Scorecard: default branch unprotected (0/10)

_{Computed from maintenance signals — commit recency, contributor breadth, bus factor, license, CI, tests, cross-checked against OpenSSF Scorecard}

ChineseOCR Lite is an ultra-lightweight Chinese optical character recognition engine that detects and recognizes text in images, including vertical text, with a total model footprint of only 4.7MB (DBNet 1.8M + CRNN 2.5M + AngleNet 378KB). It supports ONNX Runtime inference on CPU as the main branch, plus NCNN and MNN backends via separate demo projects, and provides production-ready multi-platform implementations (C++, JVM, Android, .NET). Monorepo structure: core OCR logic lives in C++ (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/) with JNI bindings; Python wrapper (backend/, model.py, config.py) provides ONNX Runtime inference and CLI entry point; separate platform-specific projects in cpp_projects/, jvm_projects/, android_projects/, dotnet_projects/ each contain native implementations; shared assets (models/, test_imgs/) and build configs (CMakeLists.txt, build.gradle) at root.

Mobile developers and embedded systems engineers deploying local OCR on resource-constrained devices; backend engineers building lightweight text extraction pipelines; Android developers needing on-device Chinese text recognition without cloud dependencies; AI researchers working with efficient deep learning inference.

Active but specialized project: README shows complete feature set, models are published, and multi-platform demos exist (C++, JVM, Android, .NET), but commit recency and CI/CD setup are not visible in provided data. The 4.7MB model size and cross-platform support suggest production viability for resource-constrained scenarios, though maintainer activity level is unclear.

Single-point-of-failure risk: project structure indicates one primary maintainer (benjaminwan pattern in Android paths); no visible GitHub Actions CI or comprehensive test suite in file list; model files are committed directly to repo, creating LFS management burden. Android minSdkVersion 21 and Kotlin stdlib dependency lock users into older API compatibility.

No specific PR or milestone data provided in file list. Project appears stable with documentation complete (README outlines all features); Android MNN library is versioned at 1.2 (versionCode 3), suggesting incremental maintenance rather than active feature development.

git clone https://github.com/DayBreak-u/chineseocr_lite && cd chineseocr_lite && pip install -r requirements.txt && python backend/main.py (for Web demo on port 8089) or pip install -e . && chineseocr test_imgs/res.jpg (for CLI).

Daily commands: Web server: cd chineseocr_lite && python backend/main.py (listens 0.0.0.0:8089). CLI: chineseocr test_imgs/res.jpg --output result.json --draw result.jpg --compress 960. C++ demo: cmake build in cpp_projects/*/. Android: gradle build in android_projects/OcrLiteAndroidMNN/.

• android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/OcrLite.cpp — Core OCR orchestration engine that integrates DbNet text detection, CrnnNet recognition, and AngleNet rotation handling.
• android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/include/OcrStruct.h — Defines all data structures (OcrResult, TextBox, ScoreNode) shared across detection, recognition, and result processing.
• android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/java/com/benjaminwan/ocrlibrary/OcrEngine.kt — JNI bridge and Kotlin API entry point that exposes native C++ OCR functionality to Android applications.
• android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/DbNet.cpp — Text detection network using DBNet model that identifies text regions and generates bounding boxes via MNN inference.
• android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/CrnnNet.cpp — Character recognition network using CRNN+LSTM model for sequence-to-sequence text prediction via MNN.
• android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/CMakeLists.txt — CMake build configuration that links MNN framework, defines native library compilation, and manages ABI targets.
• android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/AngleNet.cpp — Rotation angle detection network that corrects skewed text orientation before recognition.

• DbNet (MNN, image binary segmentation) — Detects text regions via probability map inference; outputs unordered bounding polygon coordinates.
  • Failure mode: Misses small text or merges overlapping characters when confidence threshold is too high
• AngleNet (MNN, affine transformation) — Predicts rotation angle for skewed text; corrects input before character recognition.
  • Failure mode: Over-rotates if angle ambiguous; may fail on non-Latin scripts
• CrnnNet (MNN, sequence-to-sequence LSTM) — Recognizes character sequences from cropped text regions using LSTM decoder.
  • Failure mode: Confuses similar-looking Chinese characters; fails on cursive/handwritten text
• OcrLite Orchestrator (C++, OpenCV) — Chains detection → rotation → recognition pipeline; manages memory and timing.
  • Failure mode: Crashes if model files missing; hangs if inference stalls
• OcrEngine JNI Bridge (JNI, Kotlin, Android Bitmap) — Exposes C++ OcrLite to Kotlin via JNI; marshals Bitmap and returns OcrResult.
  • Failure mode: Segfault if bitmap deallocated before inference completes; memory leaks if native pointers not freed
• ResultUtils Post-Processor — Clips polygons, orders boxes top-to-bottom, filters low-confidence results.

Add a new OCR post-processing step

1. Define output data structure in OcrStruct.h (e.g., new field in OcrResult) (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/include/OcrStruct.h)
2. Implement processing logic in OcrResultUtils.cpp using existing helper functions (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/OcrResultUtils.cpp)
3. Call the new function from OcrLite::detect() or in the JNI wrapper main.cpp (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/OcrLite.cpp)
4. Expose result field in OcrResult.kt Kotlin data class if needed for Android API (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/java/com/benjaminwan/ocrlibrary/OcrResult.kt)

Integrate a different neural network model

1. Place pre-trained .mnn model file in android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/assets/ (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/assets/dbnet.mnn)
2. Create new C++ class (e.g., NewNet.h/cpp) following DbNet.cpp pattern with MNN Interpreter (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/DbNet.cpp)
3. Add new network initialization and detect() call to OcrLite::detect() (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/OcrLite.cpp)
4. Update CMakeLists.txt to compile the new source file if needed (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/CMakeLists.txt)

Add a new Android UI feature in the demo app

1. Create a new Kotlin Activity or Dialog extending BaseDialog.kt pattern (android_projects/OcrLiteAndroidMNN/app/src/main/java/com/benjaminwan/ocr/onnx/dialog/BaseDialog.kt)
2. Instantiate OcrEngine (or inject from App) and call ocr() method (android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/java/com/benjaminwan/ocrlibrary/OcrEngine.kt)
3. Handle OcrResult in callback and render using Android View or RecyclerView (see RecyclerViewUtils.kt example) (android_projects/OcrLiteAndroidMNN/app/src/main/java/com/benjaminwan/ocr/onnx/utils/RecyclerViewUtils.kt)
4. Register Activity in AndroidManifest.xml and launch from GalleryActivity.kt (android_projects/OcrLiteAndroidMNN/app/src/main/AndroidManifest.xml)

• MNN Framework — Lightweight cross-platform neural network inference suitable for mobile; enables CPU-only deployment without CUDA
• C++ Core + JNI Bridge — Provides native performance for real-time image processing and model inference while exposing Android-friendly Kotlin API
• CMake Build System — Cross-platform compilation with fine-grained control over multiple architecture targets (armeabi-v7a, arm64-v8a)
• DBNet + CRNN + AngleNet ensemble — Specialized lightweight models (~4.7MB combined) for text detection, recognition, and rotation—optimized for mobile constraints

• CPU-only inference (no CUDA/GPU acceleration)

  • Why: Maximizes portability and minimizes dependency footprint for Android deployment
  • Consequence: Slower inference on high-resolution images; batch processing trades latency for throughput

• MNN instead of TensorFlow Lite

  • Why: Smaller runtime footprint and native support for DBNet/CRNN models used by this project
  • Consequence: Less ecosystem support; fewer online tutorials compared to TFLite

• Monolithic OcrLite orchestrator vs. modular pipeline

  • Why: Simplifies JNI boundary and reduces inter-process overhead
  • Consequence: Less flexible for swapping detection/recognition components; requires code rebuild to change model order

• Single-threaded detection loop per image

  • Why: Reduces locking complexity and memory overhead; suits real-time mobile use
  • Consequence: Batch image processing requires sequential execution; no parallelization gain on multi-core devices

• Not a multi-language OCR engine; optimized specifically for simplified and traditional Chinese
• Does not provide GPU acceleration via CUDA, OpenCL, or Vulkan
• Does not include server-side deployment or REST API (CLI/Web options exist in master branch, not shown here)
• Not a real-time streaming OCR solution; designed for per-image inference
• Does not handle PDF or document segmentation; operates on pre-cropped image input

Model files (dbnet.onnx, crnn_lite_lstm.onnx, angle_net.onnx, *.mnn) are committed directly to repo, not managed via Git LFS—expect slow clones and large .git/ folder. Android minSdkVersion 21 and buildToolsVersion 30.0.2 are pinned; updating requires testing on older devices. ONNX Runtime backend in this branch uses CPU-only inference (no GPU), despite NCNN/MNN branches supporting Vulkan/GPU. config.py path assumptions may break if models/ layout changes. CMake 3.10.2 hard requirement in Android build may conflict with newer NDK versions.

• Differentiable Binarization (DBNet) — Core text detection backbone used in dbnet/; understanding how DBNet converts pixel confidences to binary segmentation maps and why it requires the AngleNet rotation module is critical for debugging detection failures
• CRNN (Convolutional Recurrent Neural Network) — Text recognition model (crnn/ directory); combines CNN feature extraction with LSTM sequence modeling to handle variable-length text, essential for understanding why recognized text order and confidence scores vary
• Model Quantization & Lightweight Inference — The entire premise of this project: achieving 4.7MB total model size through post-training quantization (INT8) and knowledge distillation; understanding quantization artifacts is necessary for tuning accuracy-latency tradeoffs
• ONNX (Open Neural Network Exchange) Format — Model serialization standard used for all .onnx files; understanding ONNX opset versions, operator compatibility, and how ONNX Runtime handles shape inference affects multi-platform model deployment
• JNI (Java Native Interface) — Mechanism by which Android Kotlin code (OcrEngine.kt) calls C++ native library; understanding JNI marshaling, type conversions, and memory lifecycle is required for debugging Android integration
• Polygon Clipping & Geometry (Clipper Algorithm) — Text bounding box post-processing relies on clipper.cpp for contour simplification and intersection testing; understanding precision loss in coordinate quantization helps debug box offset errors
• Cross-Platform C++ Build Systems (CMake, Gradle NDK) — Project builds on Windows, Linux, macOS, Android, and .NET via different build chains; understanding CMake target linking, Gradle externalNativeBuild, and ABI filtering is essential for adding new inference backends

• PaddleOCR/PaddleOCR — Baidu's comprehensive OCR system supporting 80+ languages with lightweight models; direct competitor with more features but heavier footprint
• JAICP/kookaburra — Another ultra-lightweight Chinese OCR focused on mobile; comparable model size and multi-platform support
• microsoft/onnxruntime — Upstream inference engine used by this project's main branch; understanding ONNX model serialization and quantization is essential for contributors
• Tencent/ncnn — Alternative high-efficiency inference framework supported by this project's NCNN backend; used in cpp_projects/ and android_projects/ variants
• alibaba/MNN — Alibaba's lightweight inference engine supported by this project's MNN backend; comparable performance target and Android integration

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive unit tests for C++ OCR core modules

The Android MNN project has C++ core components (DbNet.cpp, CrnnNet.cpp, AngleNet.cpp, OcrLite.cpp) but no visible unit tests. Testing these critical inference pipelines would catch regressions early and help new contributors understand the data flow. This is especially important for a lightweight model where correctness is paramount.

• [ ] Create android_projects/OcrLiteAndroidMNN/OcrLibrary/src/test/cpp/ directory with GoogleTest configuration
• [ ] Add unit tests for OcrUtils.cpp (image preprocessing functions) in src/test/cpp/OcrUtilsTest.cpp
• [ ] Add integration tests for DbNet.cpp and CrnnNet.cpp inference pipeline in src/test/cpp/OcrLiteTest.cpp
• [ ] Update CMakeLists.txt to include test targets with gtest dependency
• [ ] Document test execution in android_projects/OcrLiteAndroidMNN/README.md

Add GitHub Actions CI workflow for Android native builds

The repo has a partial .github/agents structure but no build automation. Android NDK builds are complex and error-prone across different environments. A CI workflow would validate that CMakeLists.txt configuration works on fresh runners and catch ABI compatibility issues early (the config specifies both armeabi-v7a and arm64-v8a).

• [ ] Create .github/workflows/android-ndk-build.yml that sets up Android NDK and runs ./gradlew assembleRelease
• [ ] Configure matrix build for both armeabi-v7a and arm64-v8a as specified in OcrLibrary/build.gradle
• [ ] Add artifact upload step to retain compiled .aar files for releases
• [ ] Test against minSdkVersion 21 and targetSdkVersion 30 as defined in build.gradle

Create Python integration tests for ONNX Runtime inference pipeline

The README shows CLI usage (chineseocr test_imgs/res.jpg) and Web service functionality, but there are no visible pytest fixtures or integration tests. Adding tests would validate the end-to-end pipeline with real model files (dbnet, crnn_lite_lstm, angle_net) and help verify model file integrity during releases.

• [ ] Create tests/test_ocr_inference.py with pytest fixtures for loading test images from test_imgs/ directory
• [ ] Add test_detect_text() to verify DbNet output structure and bounding boxes
• [ ] Add test_recognize_text() to verify CRNN output format and character confidence scores
• [ ] Add test_cli_json_output() to validate the CLI's --o output format matches expected schema
• [ ] Document test execution and coverage requirements in README.md

• Add unit tests for OcrResultUtils.cpp (android_projects/.../src/OcrResultUtils.cpp exists but no visible test coverage in file list); start by creating a Kotlin AndroidTest that validates box coordinate normalization and text score filtering.
• Document the exact ONNX opset version and runtime version requirement in config.py; currently no inline comments explaining why specific model versions are needed, breaking contributor understanding when models are updated.
• Extract shared polygon geometry logic from clipper.hpp/cpp into a reusable geometry module (e.g., geometry/polygon.cpp) that C++ projects can depend on without duplication, since multiple backends (DBNet, CrnnNet) use contour processing.

• High · Outdated Android Compilation & Target SDK — android_projects/OcrLiteAndroidMNN/OcrLibrary/build.gradle. The build.gradle targets compileSdkVersion 30 and targetSdkVersion 30, released in 2020. This is significantly outdated and missing critical security patches and privacy features from Android 12+ (API 31+). Google Play now requires targeting API 33+. Fix: Update compileSdkVersion and targetSdkVersion to at least 33 or latest stable version. Review and implement required privacy changes for modern Android versions.
• High · Insecure Python Package Index Configuration — Dockerfile. The Dockerfile configures pip to use mirrors.aliyun.com as the default index without HTTPS verification explicitly stated. This could expose the build process to MITM attacks. Additionally, the --user flag usage with pip in a container is unusual and may mask permission issues. Fix: Use official PyPI index or explicitly verify HTTPS. Remove unnecessary --user flag in containerized environment. Consider using a locked requirements.txt with pinned versions and checksums.
• High · Outdated Base Container Image — Dockerfile. The Dockerfile uses 'centos:7.2.1511' which is deprecated and end-of-life since June 2024. CentOS 7 receives no security updates. This introduces significant vulnerability exposure for any deployed containers. Fix: Migrate to CentOS Stream 9, Rocky Linux 9, or AlmaLinux 9. Consider using minimal base images like ubi9-minimal for smaller attack surface.
• Medium · Missing Minification in Production Release Build — android_projects/OcrLiteAndroidMNN/OcrLibrary/build.gradle. In build.gradle, the release buildType has 'minifyEnabled false', which means ProGuard obfuscation is disabled. This makes the compiled Android library easier to reverse engineer and exposes sensitive logic, algorithms, and potential hardcoded values. Fix: Enable minifyEnabled true in release builds and implement proper ProGuard rules in proguard-rules.pro. Test thoroughly to ensure model loading and JNI calls remain functional after minification.
• Medium · Exposed Service Ports Without Authentication — Dockerfile. The Dockerfile exposes ports 5000 and 8000 without any documented authentication mechanism or authorization controls. If the web service (Tornado-based) is internet-facing, it could be accessed by unauthorized users. Fix: Implement API authentication (API keys, OAuth2, JWT). Use a reverse proxy (nginx) with rate limiting. Document security requirements. Bind to localhost by default unless explicitly configured otherwise.
• Medium · Outdated Kotlin & AndroidX Dependencies — android_projects/OcrLiteAndroidMNN/OcrLibrary/build.gradle. The gradle dependencies use older versions: junit:4.12 (from 2014), androidx versions from 2020, and don't specify the kotlin_version variable. Missing security patches in these libraries could impact the application. Fix: Update to latest stable versions: junit:5.x, androidx.test.ext:junit:1.2.x, androidx.appcompat:appcompat:1.7.x. Pin kotlin_version explicitly. Use gradle dependency verification and regular updates.
• Medium · No Explicit CMake Security Configuration — android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/CMakeLists.txt. The CMakeLists.txt configuration uses CMake 3.10.2 (from 2018) with no visible compiler security flags (ASLR, stack protectors, position-independent execution) mentioned in the gradle snippet. Fix: Add CMake compiler flags: -fPIE -fPIC -fstack-protector-strong -D_FORTIFY_SOURCE=2. Update CMake to 3.24+. Document and test ARM-specific security mitigations.
• Low · Missing Security Headers Documentation — README.md, backend/main.. No documented security headers (CORS, CSP, X-Frame-Options, etc.) are mentioned for the Tornado web service, which could lead to XSS or CSRF vulnerabilities if not properly configured. Fix: undefined

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Read in the suggested order before editing unfamiliar code. The reading-order list is computed from the actual import graph, not LLM guesses; reading bottom-up materially reduces wrong-edit risk.
3. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
4. Cite source on changes. When proposing an edit, cite the specific path/to/file.ext:Lstart-Lend you're reasoning about, the same way RepoPilot's own RAG cites code in https://repopilot.app/r/DayBreak-u/chineseocr_lite.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live DayBreak-u/chineseocr_lite repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/DayBreak-u/chineseocr_lite.

What it runs against: a local clone of DayBreak-u/chineseocr_lite — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in DayBreak-u/chineseocr_lite | Confirms the artifact applies here, not a fork | | 2 | License is still GPL-2.0 | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 40 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of DayBreak-u/chineseocr_lite. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/DayBreak-u/chineseocr_lite.git
#   cd chineseocr_lite
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of DayBreak-u/chineseocr_lite and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "DayBreak-u/chineseocr_lite(\\.git)?\\b" \\
  && ok "origin remote is DayBreak-u/chineseocr_lite" \\
  || miss "origin remote is not DayBreak-u/chineseocr_lite (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(GPL-2\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"GPL-2\\.0\"" package.json 2>/dev/null) \\
  && ok "license is GPL-2.0" \\
  || miss "license drift — was GPL-2.0 at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/OcrLite.cpp" \\
  && ok "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/OcrLite.cpp" \\
  || miss "missing critical file: android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/OcrLite.cpp"
test -f "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/include/OcrStruct.h" \\
  && ok "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/include/OcrStruct.h" \\
  || miss "missing critical file: android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/include/OcrStruct.h"
test -f "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/java/com/benjaminwan/ocrlibrary/OcrEngine.kt" \\
  && ok "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/java/com/benjaminwan/ocrlibrary/OcrEngine.kt" \\
  || miss "missing critical file: android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/java/com/benjaminwan/ocrlibrary/OcrEngine.kt"
test -f "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/DbNet.cpp" \\
  && ok "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/DbNet.cpp" \\
  || miss "missing critical file: android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/DbNet.cpp"
test -f "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/CrnnNet.cpp" \\
  && ok "android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/CrnnNet.cpp" \\
  || miss "missing critical file: android_projects/OcrLiteAndroidMNN/OcrLibrary/src/main/cpp/src/CrnnNet.cpp"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 40 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~10d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/DayBreak-u/chineseocr_lite"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

Computed from the actual import graph (no LLM). Read in this order to learn the codebase from the foundation up — each step builds on the previous ones.

1. angnet/angle.py — Foundation: doesn't import anything internally and is imported by 1 other file. Read first to learn the vocabulary.
2. angnet/__init__.py — Built on the foundation; imported by 0 downstream files.

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.