Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

9.9 KB
Raw Blame

Code map

Start with the user action below, follow its production owner, then read one representative scenario. This map locates current code and contracts; requirements belong in specifications, implementation detail beside the code, and validation results in the relevant run record.

Read progressively

  1. Find the capability below, or search with rg -n -i '<user action, symptom or domain term>' docs/code-map/.
  2. Once the relevant topic is located, prefer reading its complete code-map page, including ownership boundaries and cross-references. The search match locates the page; its surrounding context helps interpret the entry.
  3. Follow the production owner and a representative scenario, then expand into linked code, specifications or local guides as needed. Unrelated map pages need not be read by default.

Find a capability

User action Start here Representative scenario
Add model sources and inspect usable models Source admission and native configuration, Application owners Installed CLI management loop
Receive complete official model data, inspect defaults and remove its cache Feed service, shared admission, scoped defaults, metadata queries, publication guide, shared Desktop/console commands Acceptance checkpoint, confirmed cache recovery and restart, producer admission
Try a model gradually, inspect evidence and review a division draft Trial workflow, trust report, trust controls Retained evidence queries, trial interaction scenarios
Create, edit and publish a routing plan Authoring/lifecycle, compiler, domain Publication and restart
Connect a decision model or custom extension; configure difficulty routing or custom branches Decision and routing map Real CLI connection lifecycle, listener multi-turn routing
Configure, adjust or disable an Agent's models and task collaboration Agent/Worker map, Desktop feature guide Settings ordering, saved native model journey
Route an authenticated model request and apply bounded fallback Gateway map, execution core Real listener scenarios
Delegate, read, cancel or continue a Worker task Worker lifecycle and native differences Delegation, read/Continue
Inspect sessions, content, cost and competence Observation owners, decision attribution Concurrent routing timeline and incremental read bounds, opening protection projection, stage summaries
Connect, resume or adjust through a terminal/Agent CLI journey, complete Plan recovery, shared authoring, installed schemas, shared management Skill Installed Quickstart, effective evidence
Manage the service through CLI or Desktop client-core, CLI, Desktop host and native connection recovery, daemon control Real control process, Desktop test map
Configure and open the authenticated console locally or remotely Console owner, shared product session, console guide Real role-all authority/HTTP composition, production browser scenarios
Install and operate native Windows headless, including background service Windows operating guide, native kernel owners, Rust installation transaction Actual installed Control/Gateway/restart; Task is the only offered manager; SCM is refused unchanged and retains low-level tests
Upgrade Desktop and recover a failed installation Updater, installer handshake, resident restart, shared recovery facts, early admission diagnostics, storage admission Preflight → orderly stop → explicit commit; macOS installation and recovery
Install, open or update Windows Desktop Windows shell, shell payload and rollback ownership, current startup failure, local-console recovery and catalog failures, Rust Task transaction, restoration policy, owned package cleanup Native NSIS smoke, shell page/host scenarios, required native gates
Maintain agent instructions, shared skills and issue-native planning Instruction ownership, project workflow, feedback routing Pinned generated manifest, individual Claude links and current GitHub artifacts
Select, execute or diagnose a build/test run Validation workflow, test map Selection, configured runner and revision-bound reports
Build macOS / Windows Desktop or Linux / Windows headless release candidates Release candidate entry, build and publication guide, independent Unix/Windows candidate jobs Package-to-publication contract, Linux ABI gate, Windows Desktop identity; final publishing remains in release.yml

Read across boundaries

Map Scope
Architecture and ownership Shared layers, source admission, durable state, observation and change boundaries
Agent integrations and Workers Shared configuration/lifecycle owners, with Codex, Claude, Qoder, Pi, DSH and OpenCode differences together
Decision models and routing Saved connections, provider adapters, per-turn policy and competence attribution
Tests as product documentation Proof levels, reusable fixtures, representative fault cases and validation selection

Keep new navigation organized by stable responsibility, not by a provider or a completed feature. Add an ecosystem to the shared comparison and link its native leaf. Put detailed protocol rules in their canonical contract and operating steps in the existing local guide. When an owner moves, update its entry and incoming links instead of appending another implementation note to this index. Keep each matched entry a short clue about where to look next and why. Detailed rules, parameter lists, exhaustive exceptions and validation history belong in the linked specification, local guide or run record.