From 711ef98646d6edfe45b4946b56b2d58e0f4367f7 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Mon, 27 Jul 2026 20:53:37 +0000 Subject: [PATCH 1/2] docs: add VICE review improvement research and roadmap Capture industry research across CodeRabbit, Bugbot, Greptile, Codex, Cloudflare, Qodo, OpenCode, and related papers, map it to the current PRBot pipeline bottlenecks, and define a phased plan for latency, robustness, and review quality. Co-authored-by: Jai Bhasin --- docs/research/VICE_IMPROVEMENT_PLAN.md | 500 +++++++++++++++++++++++++ 1 file changed, 500 insertions(+) create mode 100644 docs/research/VICE_IMPROVEMENT_PLAN.md diff --git a/docs/research/VICE_IMPROVEMENT_PLAN.md b/docs/research/VICE_IMPROVEMENT_PLAN.md new file mode 100644 index 0000000..cdf76f1 --- /dev/null +++ b/docs/research/VICE_IMPROVEMENT_PLAN.md @@ -0,0 +1,500 @@ +# VICE / PRBot Improvement Plan + +Research synthesis and execution roadmap for making PRBot (VICE) faster, more robust, and more professional. + +Date: 2026-07-27 +Scope: industry research + full-repo analysis of the current contextual review engine +Status: planning document (no product behavior changes in this PR) + +## 1. Executive verdict + +PRBot already has the right bones for a precision-first reviewer: ephemeral Git snapshots, relationship-aware bundles, specialist routing, independent verification, deterministic anchors, and incremental fingerprinting. + +The full review is slow primarily because every run multiplies expensive work: + +1. Cold Docker image build on the Action runner. +2. Fresh bare clone and deep Git history fetch. +3. Sequential per-file diffs and O(files x tree) context discovery. +4. Many parallel tool-using specialist agents that each re-embed the same large prompts. +5. A single sequential verifier after all reviewers finish. +6. Incremental mode skipping only LLM work, not clone/index/diff work. + +Industry leaders solve latency and trust with the same hybrid pattern PRBot is already approaching: deterministic context engineering up front, bounded agentic investigation in the middle, strict verification and severity filtering at the end, and a measurable feedback loop. + +This plan turns that pattern into concrete VICE milestones. + +## 2. Industry research summary + +### 2.1 Architectural consensus + +Across CodeRabbit, Cursor Bugbot, Greptile, Qodo/PR-Agent, OpenAI Codex, Cloudflare's internal reviewer, Alibaba OpenCodeReview, OpenCode, and recent academic systems (BitsAI-CR, SWR-Bench, Lu et al. ICML 2025), successful systems converge on: + +| Pattern | Why it matters | Who does it | +| --- | --- | --- | +| Hybrid pipeline + agent | Structure for speed/trust; tools for depth | CodeRabbit, Alibaba OCR, PRBot today | +| Curated context, not dump-everything | Excess context raises false positives and latency | CodeRabbit, Qodo, Greptile | +| Multi-agent specialization | Security/perf/correctness lenses beat one generalist | Cloudflare, Greptile, Bugbot v1, PRBot | +| Independent judge / filter | Precision is the adoption bottleneck | BitsAI-CR, CodeRabbit, Bugbot, PRBot verifier | +| Incremental / delta reviews | Re-review cost dominates at scale | Cloudflare, calimero, BitsAI-CR, PRBot partial | +| Prompt caching / shared context | Shared prefixes cut cost and latency | Cloudflare (85.7% cache hit), Anthropic tooling | +| Resolution / accept metrics | Hill-climb on what developers actually fix | Cursor Bugbot | +| Repo guidance files | Encode team invariants without hardcoding | Codex `AGENTS.md`, Bugbot rules, PRBot `.prbot.toml` | +| Severity gating | Ship P0/P1 only; hide nits | Codex, Greptile filters, BitsAI-CR | +| Sandbox isolation | Never trust PR code execution | CodeRabbit microVMs, PRBot no-exec policy | + +### 2.2 Product-by-product lessons + +#### CodeRabbit + +- Hybrid, not pure agentic: static analyzers + AST/symbol context first, then targeted agent investigation. +- Ephemeral sandboxed clone with long timeouts (reviews often 10-20 minutes in their Cloud Run design). +- Cheap models compress tickets/logs/files; frontier models do hard reasoning. +- Separate judge model drops ungrounded findings before posting. +- Learnings loop from developer feedback into future reviews. +- Lesson for VICE: invest in context curation and verification before adding more agent loops. + +#### Cursor Bugbot + +- Started with 8 parallel passes + majority vote + validator. +- Moved to fully agentic tool use; largest quality gains came from dynamic context discovery. +- Key metric is resolution rate (did the author actually fix the finding before merge), not comment volume. +- Reads existing PR comments to avoid duplicates and build on prior feedback. +- Lesson for VICE: measure resolution rate; prefer fewer high-signal findings; use prior thread state. + +#### Greptile + +- Pre-indexes the full codebase into a persistent graph (files, functions, dependencies). +- Swarm of parallel agents review impact beyond the diff. +- Learns from human review comments over time. +- Configurable severity, collapse sections, path/label triggers. +- Lesson for VICE: persistent indexing beats per-run tree scans; make output noise configurable. + +#### Qodo / PR-Agent + +- Token-exact PR compression strategy; single-call tools for speed when possible. +- Asymmetric dynamic context: more lines before a change than after; expand to enclosing function/class. +- Model tiers: weak for describe/ask, strong for review, reasoning for self-reflection. +- Lesson for VICE: add token-aware bundle sizing and asymmetric hunk expansion; tier models by task. + +#### OpenAI Codex Code Review + +- Focuses on P0/P1 only. +- Uses hierarchical `AGENTS.md` as review rules and cites them. +- Manual `@codex review` plus optional auto-review. +- Structured JSON schema when built with the SDK for reliable inline comments. +- Lesson for VICE: severity-first posting; strengthen rule citation; enforce structured outputs. + +#### Cloudflare internal AI review + +- Median review ~3m39s at massive scale. +- Parallel specialist reviewers with per-task and overall timeouts. +- Shared context file + prompt caching drove 85.7% cache hits. +- Coordinator aggregates, dedups, ranks. +- Lesson for VICE: shared prompt prefixes, hard stage budgets, and cache-friendly prompt layout are the biggest latency levers after clone/index. + +#### Alibaba OpenCodeReview + +- Deterministic engineering x agent hybrid at production scale. +- Fine-grained rule matching per file keeps model attention sharp. +- Toolset distilled from production tool-call traces (frequency, repetition, impact). +- Lesson for VICE: tune the tool surface from telemetry, not intuition. + +#### OpenCode + +- Runs inside the consumer's GitHub Actions runner. +- Comment triggers (`/oc`) plus auto PR review. +- Secure by keeping execution in the customer's CI, not a third-party sandbox of untrusted plugins. +- Lesson for VICE: Actions-native trust model is already a strength; keep no-exec defaults unless sandboxed execution is explicit and optional. + +#### Coursera / education ecosystem + +- Coursera course "AI Code Review Automation with GitHub Actions" (Pragmatic AI Labs / pmat) emphasizes: + - Define review criteria before prompting. + - Combine static complexity analysis with LLM semantic review. + - Iterate prompts against real PRs. + - Handle hallucination and inconsistency explicitly. +- Coursera's own AI peer-review grading uses rubrics for consistency and speed. +- Lesson for VICE: rubric/criteria-first review beats open-ended "find issues" prompts. + +#### Academic signals (2024-2026) + +- Lu et al. (ICML 2025): code slicing + multi-role LLMs + FAR filters beat plain LLM review by large margins on industrial C++ MRs. +- BitsAI-CR: RuleChecker + ReviewFilter raised precision from ~60% to ~75%. +- SWR-Bench: multi-review aggregation can boost F1 substantially; current ACR tools underperform humans on real PRs. +- Tencent false-positive study: hybrid static + LLM filtering removes 94-98% of false alarms cost-effectively. +- Lesson for VICE: verification/filtering is not optional; it is the product. + +### 2.3 What "good" looks like in 2026 + +A professional AI PR reviewer should hit these targets: + +1. First useful signal in under ~2-4 minutes for typical PRs. +2. Full review complete before the author context-switches away (~3-6 minutes median). +3. High precision on published comments; prefer silence over nits. +4. Incremental pushes cost far less than the first review. +5. Output is sectioned, severitized, and actionable with exact anchors. +6. Failures are visible (partial/failed coverage), never falsely clean. +7. Quality is measured by resolution rate / precision / P0-P1 recall, not comment count. + +## 3. Current VICE architecture (as implemented) + +### 3.1 Pipeline today + +```text +Action start (Docker build/run) + -> entrypoint.sh maps inputs + -> authorize actor (admin-only spend) + -> fetch PR + comments + -> clone bare repo (base + head) + -> load trusted .prbot.toml + AGENTS.md from base + -> per-file git diffs -> hunks + -> sequential context graph + bundles + -> restore summary state / incremental selection + -> router LLM + -> parallel specialist reviewers (tools, up to 12 steps each) + -> sequential verifier (tools, up to 8 steps) + -> anchor resolve + fingerprint dedupe + -> formal review + summary comment + check run +``` + +### 3.2 What is already strong + +- Exact head SHA verification and merge-base diffs. +- Ephemeral bare Git store; no execution of PR code. +- Bounded read-only repository tools. +- Base-only trusted config and hierarchical `AGENTS.md`. +- Router + correctness + specialists + independent verifier. +- Deterministic anchor resolution (right/left/context/multiline/file fallback). +- Persistent summary with fingerprints and incremental bundle selection. +- Budget ceilings for minutes, tokens, cost, concurrency, and comments. +- Eval harness scaffolding (fixtures, Qodo bench, routing scorer). + +### 3.3 Why it feels slow + +Measured and structural bottlenecks: + +1. Action cold start builds from `Dockerfile` instead of a prebuilt image tag. +2. Every run reclones; incremental mode does not reuse objects or indexes. +3. Diff construction launches one `git diff` subprocess per eligible file. +4. `build_context` walks the tree repeatedly (up to 100k paths) with no inverted index or cache. +5. Same-head no-op detection happens after clone/diff/context. +6. Each reviewer prompt duplicates full patches + 16k repo map. +7. Correctness/security/performance are per-bundle tool loops; architecture/docs are grouped. +8. Router fallback treats "no specialists needed" as error and can expand work. +9. Verification waits for all reviewers, then runs one monolithic judge. +10. OpenRouter calls lack 429/5xx retry; reservations are not refunded on cancel. +11. Git/tool/stage telemetry is thin, so latency cannot be hill-climbed surgically. +12. Historical Qodo evidence: one run exhausted ~$3 / ~418k input tokens in ~274s without completing cleanly. + +### 3.4 Robustness gaps + +1. Persisted review state is restored from any issue comment containing the marker (not author-authenticated). +2. Incremental cache key ignores base SHA, models, config hash, and PRBot version. +3. Concurrent Action runs have no lease/lock. +4. Formal review publish is not idempotent if summary/check fails afterward. +5. Markdown/JSON are outside eligible extensions, so docs-only PRs can be empty. +6. Reviewer and verifier default to the same model, weakening independence. +7. No structured-output enforcement / JSON repair loop. +8. Evidence spans are not deterministically validated before publish. +9. Existing GitHub threads are not reconciled (resolved/outdated). +10. Eval catalog is still pending adjudication; CI does not gate live contextual quality. + +## 4. Target architecture for VICE + +Keep the hybrid model. Do not abandon verification or safety for raw agent autonomy. + +```text +Fast path + authorize -> load prior state by (base, head, config, version) + -> if unchanged and complete: refresh check / exit + +Prepare (parallel where possible) + reuse or shallow-fetch Git objects + one authoritative diff partition + load/update persistent symbol+import index for changed neighborhood + static signals (optional lints later) + +Triage + cheap router/classifier: risk, languages, specialist need, size class + allow zero specialists + choose review depth: skim / standard / deep + +Review + shared cached context prefix + token-bounded bundles + parallel specialists with per-task timeouts + tool use only for unresolved questions + +Judge + batch verify candidates (not one giant prompt forever) + drop P3 by default; require confidence + grounded evidence + majority / agreement boost when overlapping + +Publish + idempotent review upsert + summary + check + stage latency + resolution telemetry +``` + +North-star product promise: + +- Fast enough to feel like a teammate already looking. +- Quiet enough that engineers trust every comment. +- Honest enough to say when coverage was partial. + +## 5. Prioritized roadmap + +### Phase 0 - Instrumentation and truth (foundation) + +Goal: know where time and money go before changing behavior. + +Deliverables: + +1. Stage timers in summary output: auth, clone, diff, context, router, reviewers, verifier, publish. +2. Per-agent counters: HTTP calls, tool calls, input/output tokens, wall time, queue wait. +3. Cache-key fields logged even before caching exists. +4. Fail the summary cleanly when stages truncate. + +Acceptance: + +- Local dry-run and one live self-test PR show a complete stage breakdown. +- Qodo batch rows record stage timings. + +### Phase 1 - Latency wins with low quality risk + +Goal: cut wall-clock without changing review semantics much. + +1. Ship a prebuilt GHCR/Docker Hub image; stop rebuilding the binary on every consumer run. +2. Move same-head complete-review short-circuit before clone when state + check already prove completeness. +3. Parallelize independent GitHub fetches (check runs, linked issue, comments where safe). +4. Compute one multi-file `git diff` and partition in memory instead of N subprocesses. +5. Add read/parse caches inside a run for `list_tree`, file bytes, and syntax signals. +6. Cap and share the repo map; put stable system/instructions/schema first for provider prompt caching. +7. Allow router to assign zero specialists without fallback-to-all. +8. Add OpenRouter retries with jittered backoff for 429/5xx. +9. Bound clone deepen policy more aggressively; fail soft with partial history rather than unshallowing huge repos by default. +10. Enforce end-to-end deadline across publish, not only LLM `.send()`. + +Expected impact: + +- Large cold-start reduction from image reuse. +- Material CPU reduction on medium/large repos from context caching and single diff. +- Fewer wasted specialist calls on simple PRs. + +### Phase 2 - Incremental review that actually saves work + +Goal: second push reviews only what changed, including prepare cost. + +1. Authenticate summary state (bot author + signed/versioned payload). +2. Key state by `base_sha + head_sha + engine + models + config_hash + prbot_version`. +3. Persist a lightweight neighborhood index artifact in Actions cache keyed by repo + base SHA. +4. On synchronize, recompute only affected bundles and related edges. +5. Reconcile prior findings with current diff and GitHub thread resolution. +6. Add a run lease comment/check to prevent duplicate concurrent publishes. +7. Make formal review creation idempotent via fingerprint of `(head, findings set)`. + +Expected impact: + +- Incremental runs approach "router + few specialists + verify" instead of full prepare+review. + +### Phase 3 - Quality and professionalism + +Goal: fewer comments, higher resolution rate, clearer UX. + +1. Default publish policy: P0/P1 always; P2 only under budget; P3 suppressed unless configured. +2. Cite matching `.prbot.toml` / `AGENTS.md` rules in finding bodies. +3. Split verification into batches; optionally use a stronger/different verifier model by default. +4. Deterministically validate evidence paths/line ranges before accept. +5. Reject ambiguous anchors instead of silent file-level downgrade when severity is P0/P1 (or mark confidence drop). +6. Expand eligible types for docs steward: Markdown and selected JSON/YAML config. +7. Token-aware bundle packing and asymmetric hunk expansion (more before than after; enclose function/class). +8. Read prior human/bot comments to suppress duplicates (Bugbot/Codex pattern). +9. Richer summary UX: risk score, coverage map, skipped paths, stage timings, model tiers. +10. Optional "review effort" input: `low | medium | high` mapping to specialist count, tool steps, and verifier strictness (Copilot pattern). + +### Phase 4 - Context intelligence + +Goal: stop rebuilding naive graphs every run. + +1. Replace repeated tree scans with a persistent symbol/import index (tree-sitter based, language pack already present). +2. Build true edges for imports, definitions, references, tests, and manifests. +3. Precompute repo map summaries with cheap models only when the index is cold or base moved far. +4. Optional static signals: `clippy`/`eslint`/`ruff` as data for the model, still without executing untrusted project scripts by default. +5. Path-rule aware specialist forcing (auth paths always get security, etc.). + +### Phase 5 - Learning loop and release quality + +Goal: hill-climb like Bugbot/CodeRabbit. + +1. Adjudicate the 50-case fixture catalog; enforce precision/recall gates in CI. +2. Keep Qodo scoreboard green as a release signal. +3. Add resolution-rate estimator: at merge time, classify whether active findings were fixed. +4. Track dismiss/ignore patterns from issue comments and thread resolutions. +5. Repin default review/verification models only after evals pass. +6. Split oversized modules (`git.rs`, `client.rs`, `tools.rs`, orchestration) under the 300/500 line guidance as features land. + +## 6. Concrete design decisions + +### 6.1 Keep no-exec as default + +CodeRabbit's power comes partly from running analyzers in microVMs. +VICE's Action-native trust model is different and already a selling point. + +Decision: + +- Default remains: no project code execution, no model-selected shell, no network tools. +- Optional later: `enable_static_analyzers=true` running only allowlisted tools on a fetched snapshot with explicit sandboxing. + +### 6.2 Prefer hybrid depth over unbounded agents + +Bugbot gained quality by going agentic. +Cloudflare and CodeRabbit show agentic loops need hard budgets. + +Decision for VICE: + +- Keep tool-using specialists. +- Reduce default tool steps for `low` effort. +- Add per-task timeouts and early-stop when no suspicious signals remain. +- Never let tool loops exceed the global minute/token budget. + +### 6.3 Severity-first product surface + +Codex posts P0/P1 only. +Noise kills adoption faster than missed nits. + +Decision: + +- Make `max_comments` a publish cap, not a quality target. +- Add `min_priority` (default P2) and `include_p3=false`. +- Summary can still mention suppressed nit counts. + +### 6.4 Model tiering + +| Role | Tier | Default intent | +| --- | --- | --- | +| Reaction / classify / compress | weak/fast | cheap, cached | +| Router | weak/fast or review | structured JSON | +| Correctness / security | review | current review model | +| Architecture (large/cross-file) | review or reasoning | deeper only when routed | +| Verifier | verification (ideally different family) | adversarial filter | + +### 6.5 Cache hierarchy + +1. Action image cache (binary). +2. Git object cache (repo pack by remote URL). +3. Symbol index cache (base SHA). +4. Prompt-prefix cache (provider). +5. Review state cache (PR summary, authenticated). + +## 7. Suggested implementation slices (small PRs) + +These are ordered for frequent commits and measurable gains: + +1. `telemetry`: stage timings + agent counters in summary. +2. `action-image`: publish/consume prebuilt image. +3. `fast-noop`: authenticated state + pre-clone same-head exit. +4. `diff-once`: single diff partition + in-run file caches. +5. `router-zero`: allow empty specialist assignment; remove forced fallback. +6. `llm-retry`: OpenRouter retry/backoff + reservation refunds. +7. `prompt-cache`: reorder prompts for stable prefixes; shrink duplicated maps. +8. `verify-batch`: batched verifier + evidence validation. +9. `severity-gate`: min priority + rule citations. +10. `incremental-index`: Actions cache for neighborhood index. +11. `docs-json`: eligible Markdown/JSON for documentation steward. +12. `evals-gate`: adjudicated fixtures + CI quality gate. +13. `effort-levels`: `low|medium|high` review depth input. +14. `module-splits`: file-size cleanup as each area is touched. + +## 8. Success metrics + +Track per release: + +| Metric | Current signal | Target direction | +| --- | --- | --- | +| Median end-to-end review latency | often dominated by prepare + many LLM loops | down sharply on typical PRs | +| p95 latency | unknown / uninstrumented | bounded under deadline with honest partials | +| Estimated USD / PR | can approach $3 ceiling | down via cache + triage + incremental | +| Input tokens / PR | can exceed hundreds of thousands | down via shared context + compression | +| Published comments / PR | capped at 12 | fewer, higher severity | +| Precision on adjudicated fixtures | pending | >= 90% | +| P0/P1 recall | pending | >= 75% | +| Anchor validity | partially enforced | ~100% for published inline comments | +| Resolution rate | not measured | rising over time | +| Incremental speedup vs full | LLM-only today | prepare+LLM both reduced | + +## 9. Risks and non-goals + +Risks: + +- Over-caching can hide base-branch updates if keys omit base SHA. +- Aggressive severity filtering can miss real P2s unless effort mode exists. +- Persistent indexes add operational complexity in Actions. +- Same-model verifier can rubber-stamp reviewer findings. + +Non-goals for the near term: + +- Becoming a full coding agent that pushes fixes by default. +- Running untrusted PR build/test scripts in-process. +- Matching CodeRabbit's 20-minute deep sandbox reviews at the cost of CI snappiness. +- Replacing human review on high-risk changes. + +## 10. Appendix A - Repository map for implementers + +Important paths: + +- `src/review/` - authorization, orchestration, incremental selection +- `src/repository/` - Git, diff, context, tools, syntax, safety +- `src/agents/` - router, tasks, specialists, verifier, prompts +- `src/reporting/` - anchors, fingerprints, summary state +- `src/llm.rs` + `src/llm/budget.rs` - OpenRouter loop and ceilings +- `src/github/` - API client and publish helpers +- `action.yml` / `Dockerfile` / `entrypoint.sh` - Action wiring +- `evals/` - fixtures, Qodo bench, scoreboard + +Highest-churn files for Phase 1-2: + +- `src/repository/context.rs` +- `src/repository/diff.rs` +- `src/repository/git.rs` +- `src/review/contextual.rs` +- `src/review/incremental.rs` +- `src/review/review_context.rs` +- `src/agents/mod.rs` +- `src/agents/router.rs` +- `src/agents/verifier.rs` +- `src/llm.rs` +- `action.yml` + +## 11. Appendix B - Primary sources consulted + +Industry / product: + +- CodeRabbit architecture and hybrid AI blogs; Google Cloud Run writeup +- Cursor Bugbot engineering blog and docs +- Greptile graph-context and system architecture docs +- Qodo/PR-Agent dynamic context and compression docs +- OpenAI Codex GitHub review docs, custom `AGENTS.md` rules, Codex SDK cookbook +- Cloudflare "Orchestrating AI Code Review at scale" +- Alibaba OpenCodeReview README and hybrid design notes +- OpenCode GitHub Actions docs +- GitHub Copilot code review docs (effort levels, auto-review) +- Coursera "AI Code Review Automation with GitHub Actions" course outline +- calimero-network/ai-code-reviewer multi-agent/incremental patterns + +Academic / empirical: + +- Lu et al., Towards Practical Defect-Focused Automated Code Review (ICML 2025) +- BitsAI-CR: Automated Code Review via LLM in Practice (arXiv 2501.15134) +- SWR-Bench (arXiv 2509.01494) +- Reducing False Positives in Static Bug Detection with LLMs (Tencent industrial study) + +## 12. Recommended immediate next PR + +Implement Phase 0 + the first three Phase 1 items in one focused engineering track: + +1. Stage telemetry in the summary comment. +2. Prebuilt Action image. +3. Pre-clone same-head no-op (with authenticated state). +4. Single-diff partition + in-run caches. + +That sequence attacks the user's main complaint (time) while making later quality work measurable. From 1b37b2e0b45719a159d4fc5704ec0d6f96e385ca Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Mon, 27 Jul 2026 20:53:41 +0000 Subject: [PATCH 2/2] docs: link VICE improvement plan from README and changelog Co-authored-by: Jai Bhasin --- CHANGELOG.md | 3 +++ README.md | 2 ++ 2 files changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6cb3d8e..dbd776f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,9 @@ ## [Unreleased] +### Added +- Research and roadmap for faster, more robust VICE/PRBot reviews in `docs/research/VICE_IMPROVEMENT_PLAN.md` + ## [0.2.0] - 2026-07-27 ### Added diff --git a/README.md b/README.md index 68e0bc6..7fa8f89 100644 --- a/README.md +++ b/README.md @@ -195,3 +195,5 @@ src/llm.rs OpenRouter tool loop, concurrency, and budget ledger The architecture uses independently implemented patterns inspired by [PR-Agent context management](https://docs.pr-agent.ai/core-abilities/dynamic_context/), [Aider repository maps](https://aider.chat/docs/repomap.html), [OpenCode tools](https://opencode.ai/docs/tools), [Serge](https://huggingface.github.io/serge/), [Alibaba OpenCodeReview](https://github.com/alibaba/open-code-review), [Mira](https://docs.miracode.ai/), and the [Codex GitHub Action](https://github.com/openai/codex-action). No source code was copied from those projects. + +For the latency, robustness, and quality roadmap based on industry research (CodeRabbit, Bugbot, Greptile, Codex, Cloudflare, Qodo, OpenCode, and related papers), see [`docs/research/VICE_IMPROVEMENT_PLAN.md`](docs/research/VICE_IMPROVEMENT_PLAN.md).