VirtusLab/orca
62.3
Adequate · 7 November 2026
34.4k
lines of production code
Scala
primary language
4
measurements over time
What this system is
Features
Added simple Rust smoke-test project for Orca
A new tiny Rust crate has been added to the examples directory to serve as a smoke-test target for Orca. This project includes basic arithmetic functions (add and subtract) along with corresponding unit tests, a README explaining how to run the tests, and a .gitignore file to exclude build artifacts and the Cargo.lock file.
examples/runnable/01-simple/test-project · high confidence
Automated PR creation with review findings and best-effort handling
The flow now includes helpers to automatically push a branch and open a Pull Request, featuring an AI-driven summary of changes and explicit reporting of any open review findings in the PR body. A strict mode (\openPrFromBranch\) fails the run if the PR cannot be opened, while a best-effort mode (\openPrIfGitHub\) allows the run to succeed even if GitHub is unavailable or the push fails, logging the reason instead. The system also supports stable comment markers for updating existing comments and ensures that open review findings are reported in both the PR body and the run output.
flow/src/main/scala/orca/pr · high confidence
Initial project scaffolding and documentation
The repository is bootstrapped with a multi-module Scala 3 project structure, including an Apache 2.0 license, a README with installation and usage instructions, and detailed contributor guides (AGENTS.md, CONTRIBUTING.md). A Read the Docs configuration is added to host user documentation at orca.virtuslab.com, and a scalafmt configuration is set up to handle Scala 3 syntax, including an exclusion for capture-checking code that the formatter does not yet support.
(repo-wide) · high confidence
Introduce Claude backend with model tiers, reasoning effort, and network tool controls
Added a new Claude backend integration that exposes distinct model tiers (Haiku, Sonnet, Opus 1M, and Fable) via extension methods, allowing users to select a specific model for a run. The backend now supports a reasoning \--effort\ flag (e.g., \withEffort(Effort.Medium)\) to tune model behavior, and provides a \withNetworkTools\ method to safely add network-read capabilities (like \WebFetch\) to read-only turns while explicitly rejecting write-capable builtins. This change includes the core agent wiring, model definitions, and argument streaming logic for the Claude CLI.
claude · high confidence
Introduce the Orca Shell with interactive menu and CLI commands
The shell now provides a unified entry point: running \orca\ without arguments launches an interactive menu-driven shell (including a first-run wizard and configuration summary), while passing arguments invokes a curated CLI surface with commands like \run\, \create\, \fork\, \continue\, \config\, and \clear-stack\. This change also adds Scala syntax highlighting for nano via \scala.nanorc\ and introduces a three-tier flow resolution system (project, global, built-in) with typo-tolerant lookups.
shell/src/main · high confidence
Introduces durable, resumable LLM sessions with stage-scoped identity
The flow module now supports durable, resumable LLM sessions via the new \FlowSession\ class and \agent.session(name, seed)\ extension. Sessions are keyed by name and the specific stage in which they are minted, ensuring that each stage owns its own conversation history and that resumes correctly re-key sessions if stage structure changes. The implementation includes \FlowControl\ and \StageFrames\ to manage stage lifecycles, occurrence counters, and thread affinity, preventing concurrent access from forks. Sessions persist their state to disk (\.orca/cache/\) and handle resume wire IDs, allowing flows to survive crashes and resume from the last committed state. Additionally, \FlowContext\ and \FlowControl\ are separated into distinct capabilities, and new accessors like \planningAgent\, \codingAgent\, and \reviewAgent\ allow flows to use role-based agents resolved from settings.
flow/src/main/scala/orca · high confidence
New 'simple' example demonstrating autonomous planning and review loops
Added a new runnable example (\examples/runnable/01-simple\) that showcases a minimal Orca flow where an agent plans tasks in a single turn and implements them sequentially with a review-and-fix loop. The example includes a seed script (\create-test-project.sh\) to set up a temporary Rust calculator project and instructions for running the flow via \scala-cli\, providing a concrete starting point for users to understand the autonomous planning capability.
examples/runnable/01-simple · high confidence
New Claude Code and Codex LLM backends
Added support for the Claude Code and Codex CLI agents as new LLM backends. The Claude Code backend drives the \claude\ CLI in \stream-json\ mode, handling session management, tool permissions (read-only, network-only, full), and structured output via JSON schemas. The Codex backend supports both single-turn (\exec\) and multi-turn (\exec resume\) workflows, managing sandbox modes (read-only, workspace-write) and MCP server integration. Both backends include dedicated argument builders, JSON decoders for their respective protocols, and enforcement logic to ensure tool access aligns with the configured agent tier.
repository · high confidence
New Codex and Gemini agent backends with model tiers
Users can now run autonomous and interactive agent turns using the Codex and Gemini CLI tools. The Codex backend drives \codex exec --json\, supports multi-turn sessions via server-minted IDs, and offers a strong default model (\gpt-6.1-sol\) with a cheap tier (\gpt-6-luna\). The Gemini backend drives \gemini -p\ with stream-json output, supports session resumption, and provides a strong default (\gemini-3.1-pro-preview\) alongside a fast tier (\gemini-3.8-flash\). Both backends handle interactive mode by wiring an \ask\_user\ MCP bridge, fold system prompts into user prompts, and enforce tool permissions (read-only, network-only, or no tools) via CLI flags.
gemini · high confidence
New agent prompt templates and concurrency capability split
The tools module now includes a new set of prompt templates for autonomous, interactive, and retry agent turns, along with a structured output schema for raw JSON responses. Additionally, a new concurrency capability split is introduced using capture checking, with separate tokens for in-stage LLM calls (InStage) and workspace writes (WorkspaceWrite), ensuring that workspace mutations are sequenced by the flow thread and cannot cross fork boundaries.
tools/src/main · high confidence
New and reshaped built-in flows for epics, implementation, quick tasks, issue resolution, and review-only analysis
The \flows/\ directory now includes five distinct, ready-to-run Scala scripts that define how the Orca agent handles different workloads. \epics.sc\ manages large changes by breaking them into epics and tasks with iterative review; \implement.sc\ plans and implements features with a final whole-run review; \quick.sc\ handles small, direct tasks without planning; \resolve.sc\ triages and fixes GitHub issues or bug reports, including test reproduction and PR creation; and \review.sc\ performs read-only analysis of PRs, branches, or diffs, posting findings as comments when applicable. All flows are updated to use the Orca 0.2.0 library and Scala 3.9.0.
flows · high confidence
New progress and session persistence infrastructure
The system introduces dedicated on-disk stores for tracking run progress and managing durable agent sessions. ProgressStore now persists a structured JSON log of stage entries and published work, enabling the runtime to resume interrupted runs by relaunching the exact same flow script (identified via the new FlowSource enum) and validating the run context via RecoveryCheck. Additionally, SessionStore maintains machine-local cache records of agent conversations in .orca/cache, ensuring that if a run fails and is resumed, the agent can reconnect to the original conversation context rather than starting fresh.
flow/src/main/scala/orca/progress · high confidence
New runnable example with streamlined seeding and local development support
A new \01-simple\ example is introduced, providing a self-contained workflow to seed a starter project and run an Orca flow in a single step. The new \create-test-project.sh\ harness supports several key options: \--run\ executes the flow immediately after seeding, \--settings\ pre-populates stack configuration to skip auto-discovery for deterministic or offline runs, and \--local\ allows developers to test against a local \sbt publishLocal\ build instead of the published Maven Central artifact. This replaces the previous requirement to manually copy flow scripts and manage git initialization for testing.
examples/runnable · high confidence
New runner entry point and run-target model
The runner now exposes a \flow\ entry point in \flowEntry.scala\ that manages the complete lifecycle of a run, including role-based agent resolution (planning, coding, review) and worktree support. This is underpinned by new \RunTarget.scala\ and \FlowSourceProperty.scala\ files which define how runs target branches or worktrees and how the flow source is communicated to child processes, respectively. A new \exports.scala\ file centralizes the public API surface for flow scripts, re-exporting agents, events, review tools, and opaque types to simplify imports.
runner/src/main/scala/orca · high confidence
Behavioural changes
2 commits (0 fixes) modifying codex, opencode, pi
A change to existing behaviour in codex, opencode, pi — 2 commits, 35 files: “Support effort on codex, pi and opencode, and in settings (\#299)”; “Nest packages to narrow visibility (\#296)” (refs \#299, \#296).
codex, opencode, pi · medium confidence · unverified
Centralized event dispatching with automatic listener quarantine
The event system now uses a dedicated \EventDispatcher\ that synchronously forwards events to registered listeners. If a listener throws an exception, it is immediately quarantined for the remainder of the run, ensuring that a single broken listener cannot disrupt the flow for others. Additionally, a new \CostResolvingDispatcher\ wraps the listener fan-out to resolve pricing for unpriced turn events once, ensuring consistent cost reporting across all listeners and logs.
flow/src/main/scala/orca/events · high confidence
Introduce typed stack settings and auto-discovery parser
The settings module now uses a typed parser to handle per-project stack configurations, introducing a \SettingsEntry\ enum to represent discovered commands, disabled gates, and skipped entries with reasons. This change implements the core logic for auto-discovering stack keys and rendering them into a live settings file, ensuring that disabled or invalid commands are explicitly recorded to prevent re-discovery.
flow/src/main/scala/orca/settings · high confidence
Introduction of in-memory session cache for durable session tracking
A new \SessionStore\ trait has been added to manage durable session records within the local machine cache rather than the committed progress log. This component acts as a projection of the run's event log, covering sessions minted since the run's last success. It ensures that session data survives uncommitted work teardowns (such as \git reset --hard\ or \git clean -fd\) and resume-time stashing, allowing failed stages to be re-run while maintaining continuity with the original conversation. The store is thread-safe and uses a last-write-wins strategy for upserts by session key.
flow/src/main/scala/orca/sessions · high confidence
Orca project configuration and build automation settings
The .orca directory now includes a settings.properties file that defines the project's code quality and build workflow. This configuration specifies sbt scalafmt for formatting, strict compilation flags for linting, and sbt testFull for running unit tests using the munit framework, effectively establishing the automated development gates for the orca component.
.orca · high confidence
Redesigned terminal output with stage indentation, status bar, and tool step summaries
The terminal interface now features a structured event log with stage-based indentation, a persistent animated status bar at the bottom, and concise one-line summaries for tool calls. Agent attribution is added when multiple agents run in parallel, and read-only tool calls are collapsed to reduce noise. The renderer uses a single-threaded actor model for thread-safe output, supports multiline input with literal-newline keys, and forces UTF-8 encoding to ensure glyphs display correctly in non-UTF-8 locales.
runner/src/main/scala/orca/runner/terminal · high confidence
Review loop now tracks and displays unresolved findings
The review loop now explicitly tracks findings that remain open after the fixer's attempts and displays them to the user. This is implemented via a new \FindingId\ opaque type that stably identifies findings across rounds (using round/key combinations, seed indices, or custom flow IDs) so that reworded titles or duplicate titles do not break tracking. The \ReviewLoopPrompts\ now include an 'open findings' block in reviewer prompts, listing each open finding's ID, title, location, and the reason it was left open, and instructing reviewers to reference the ID if they re-report it. The \ReviewFormatting\ module adds a \formatOpenFindings\ function that renders these remaining findings in the run output, showing the count, titles, locations, and reasons. Additionally, \ReviewLogging\ records the specific payload shape (updated diff, sections, paths, or already-seen note) sent to reviewers in each round, improving traceability of what reviewers saw.
flow/src/main/scala/orca/review · high confidence
Runner introduces concurrency guards, per-attempt trace logging, and worktree branch handoff
The runner module now enforces strict concurrency controls to prevent nested or parallel flows from corrupting the git tree, using OS file locks for worktrees and working directories alongside a process-wide guard that throws clear errors when conflicts occur. Execution traces are now captured per-attempt via a dedicated logback rolling file appender, providing full diagnostic logs without cluttering the console output. Additionally, the runner manages git state more intelligently by automatically determining whether to return the user to their original branch or stay on the feature branch after a run, based on whether the work was published and whether a worktree was used.
runner/src/main/scala/orca/runner · high confidence
Structured bug triage outcomes and reusable prompt resources
The planning module now exposes a typed \Triage\ sum type with three distinct outcomes—\NotABug\, \Untestable\, and \Testable\—replacing the previous wide-record approach to provide callers with precise, pattern-matchable data for each scenario. Additionally, default prompt instructions for planning, assessment, triage, and review are now centralized in \PlanPrompts\ and loaded from classpath resources, allowing users to easily override or extend the boilerplate instructions used by the planning agents.
flow/src/main/scala/orca/plan · high confidence
Test coverage
5 commits adding/updating tests in shell/src/test/scala/orca/shell/menu; 5 commits adding/updating tests in shell/src/test/scala/orca/shell/wizard; Added CLI command parsing and validation tests; Added Scala CLI smoke test for published library integration; Added compile-time API surface tests for the flow DSL; Added comprehensive test coverage for the review loop subsystem; Added comprehensive test coverage for the runner module; Added test coverage for core Orca tools and agent subsystems; Added tests for CLI argument parsing and flow source properties; Added tests for Orca Shell actions and menus; Added tests for PR body generation and PR opening flows; Added tests for built-in flow compilation, catalog logic, and editor/viewer behavior; Added tests for progress tracking and branch validation logic; Added tests for settings file parsing, rendering, and agent configuration; Added tests for shell run mechanics and dependency override behavior; Added tests for shell session persistence and resumption logic; Added tests for the Orca Shell flow authoring and sandbox creation features; Added tests for the planning grid, plan serialization, triage validation, and bug reproduction flows; Added tests for the run event log and session management components; Added tests for the terminal runner layer; Added tests to verify runtime git isolation for flow scripts; Added unit tests for flow module components.
Dependencies
Bootstrap multi-module build with new LLM backends and tooling
The project introduces a multi-module sbt build structure, separating core functionality into a \tools\ module and adding distinct modules for LLM backends (\claude\, \codex\, \pi\, \opencode\, \gemini\) and flow execution (\flow\), all orchestrated by a \runner\ module. This restructuring integrates key dependencies including \tapir\ (1.13.18), \ox\ (1.0.2), \chimp\ (0.5.2), and \jsoniter\ to support the new backend implementations and shared MCP server capabilities. The build also configures test isolation via forking and git environment variable overrides to ensure stable execution across the new module layout.
(dependencies) · high confidence
Introduce sbt build infrastructure and dependency management
The project now includes a complete sbt build configuration, establishing sbt version 1.12.11 and adding plugins for software-mill publishing and scalafmt. A centralized \Dependencies.scala\ file defines the project's library coordinates, including Scala 3.9.0, Tapir 1.13.31, Ox 1.0.8, chimp 0.5.2, and various testing and utility libraries. Additionally, custom build tasks have been added to detect class name case collisions on case-insensitive filesystems, concatenate documentation pages for publishing, and update Scala CLI version references in documentation during releases.
project · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 61 → 62 (+1.2)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 57 → 57 (+0.0)
- Architecture 92 → 90 (-2.6)
- Maturity 64 → 100 (+35.9)
- Readiness 56 → 55 (-0.9)
- Security 68 → 62 (-6.2)
- Performance 100 → 100 (+0.0)
Resolved (20)
- ADR has no Consequences section (adr/0007-codex-exec-jsonl-driver.md)
- ADR has no Consequences section (adr/0013-persistent-plans.md)
- ADR has no Consequences section (adr/0015-gemini-stream-json-driver.md)
- ADR has no Consequences section (adr/0022-review-rework.md)
- ADR has no Decision section (adr/0018-stage-bound-flow-runtime.md)
- ADR not followed: 0001. Implement Orca in direct-style Scala 3 on Ox (adr/0001-direct-style-scala-on-ox.md)
- Checkable ADR rule enforced only by prose: 0004. Split the codebase into tools / flow / backend / runner modules (adr/0004-module-layout.md)
- Documentation: written for insiders (docs/authoring/capabilities.md)
- Outdated: ch.qos.logback:logback-classic
- Outdated: com.github.plokhotnyuk.jsoniter-scala:jsoniter-scala-core_3
- Outdated: com.github.plokhotnyuk.jsoniter-scala:jsoniter-scala-macros_3
- Outdated: com.lihaoyi:fansi_3
- Outdated: com.lihaoyi:mainargs_3
- Outdated: com.softwaremill.chimp:chimp-server_3
- Outdated: com.softwaremill.ox:core_3
- Outdated: com.softwaremill.sttp.apispec:jsonschema-circe_3
- Outdated: com.softwaremill.sttp.tapir:tapir-apispec-docs_3
- Outdated: com.softwaremill.sttp.tapir:tapir-netty-server-sync_3
- Outdated: org.jline:jline
- Outdated: org.jline:jline-console-ui
New (30)
- ADR declares no status (adr/0010-prompts-and-helpers-convention.md)
- ADR declares no status (adr/0011-reviewer-roster.md)
- ADR declares no status (adr/0012-mcp-host-bridge.md)
- ADR declares no status (adr/0013-persistent-plans.md)
- Classify ADR enforcement: 0001. Implement Orca in direct-style Scala 3 on Ox (adr/0001-direct-style-scala-on-ox.md)
- Classify ADR enforcement: 0002. Flow scripts use a context-function DSL with an ambient FlowContext (adr/0002-context-function-flow-dsl.md)
- Classify ADR enforcement: 0003. LLM backends are pluggable behind an AgentBackend[B <: Backend] trait (adr/0003-pluggable-llm-backends.md)
- Classify ADR enforcement: 0004. Split the codebase into tools / flow / backend / runner modules (adr/0004-module-layout.md)
- Classify ADR enforcement: 0005. Reshape the flow DSL so import orca.{*, given} is the whole ceremony (adr/0005-flow-dsl-reshape.md)
- Classify ADR enforcement: 0006. Drive Claude Code via stream-json instead of TTY handoff (adr/0006-stream-json-conversation-driver.md)
- Classify ADR enforcement: 0007. Drive Codex via codex exec --json stdio JSONL (adr/0007-codex-exec-jsonl-driver.md)
- Classify ADR enforcement: 0008. Terminal output: event log + status bar (adr/0008-terminal-output-design.md)
- Classify ADR enforcement: 0009. Announce typeclass for friendly summaries of structured outputs (adr/0009-announce-typeclass.md)
- Classify ADR enforcement: 0013-persistent-plans (adr/0013-persistent-plans.md)
- Classify ADR enforcement: 0014. OpenCode server driver (adr/0014-opencode-server-driver.md)
- Classify ADR enforcement: 0015. Drive Gemini CLI via gemini --output-format stream-json stdio JSONL (adr/0015-gemini-stream-json-driver.md)
- Classify ADR enforcement: 0016. ToolSet capability axis and planner read-only network access (adr/0016-toolset-capability-axis-and-planner-network.md)
- Classify ADR enforcement: 0017. Configurable OpenCode serve launcher (adr/0017-opencode-configurable-launcher.md)
- Classify ADR enforcement: 0018. Stage-bound flow runtime: resumable stages, capabilities, progress log (adr/0018-stage-bound-flow-runtime.md)
- Classify ADR enforcement: 0019. Per-project stack settings with auto-discovery (adr/0019-project-stack-settings.md)
- …and 10 more
Changes since last survey
- 3 commits — 3 feature/other, 0 fixes
By area
- docs/research — 1 commit
- flow/src — 1 commit
- shell/src — 1 commit
Notable commits
- change: Release 0.2.1
- change: Support creating draft PRs (#300)
- change: Support effort on codex, pi and opencode, and in settings (#299)
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
VirtusLab/orca was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 7 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 026c41dafe82c9a24659e4f5b3c3afe578c0dfb0 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-c34be012586e.