Skip to content

Latest commit

 

History

History
70 lines (62 loc) · 17.7 KB

README.md

File metadata and controls

70 lines (62 loc) · 17.7 KB

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
Read or preview API key allowances from the CLI Installed request schemas, allowance preview CLI input and discovery, real allowance lifecycle
Find model routing and delegation instructions for an Agent Website guide maintenance, Agent tutorial registry Bilingual guide and website validation
Review a completed task and tune routing prompts or trust Routing review guide, installed management Skill Guide handoff contract
Receive complete official model data, inspect defaults and remove its cache Bundled resource budgets, Feed service, shared transport and admission, scoped defaults, metadata queries, independent publication and development-source guide, feed-only recommendations, shared Desktop/console commands Gzip negotiation and decoded bounds, bundled model-file and registry boundaries, Acceptance checkpoint, confirmed cache recovery and restart, development publication and recorded-reader admission
Try a model gradually, inspect evidence and review a division draft Recommendation entry, trial configuration and connections, targeted connection reuse, saved subscription owner lookup, combined setup capture, trust report, shared trust controls Recommendation scenarios, retained evidence queries, trial interaction scenarios, setup identity and feedback, connection target reuse
Create, edit and publish a routing plan Model-detail entry, 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
Run Codex Desktop alongside a separate CLI profile Independent instance, native launch, skill sharing Independent lifecycle and restart, production interaction
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, timeline presentation, exact model labels Concurrent routing timeline and incremental read bounds, admission and presentation, 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
Identify the installed CLI or daemon build offline CLI version entry, daemon entry, shared compiled identity CLI process identity, daemon process identity, native Windows console and pipes
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
Find an available Desktop update and open its controls Shared updater state, sidebar entry, Settings destination Discovery and guarded navigation, compact Windows shortcut
Upgrade Desktop and recover a failed installation Updater, installer handshake, resident restart, Windows update stage lifecycle, shared recovery facts, early admission diagnostics, storage admission, completed-batch identity boundary Preflight → orderly stop → explicit commit; macOS installation and recovery, upgrade/reopen phase and recovery scenarios
Open HiRoute from the Omarchy launcher, update, remove or recover its user runtime Linux Desktop guide, Linux host, shared console admission, standalone installer Interrupted Linux publication and recovery, host interaction tests
Install, open or update Windows Desktop Windows shell, shell payload and rollback ownership, current startup failure, copyable installer and uninstall diagnostics, 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, project feedback, shared feedback recording Pinned generated manifest, individual Claude links, current GitHub artifacts and a feedback preview on the intended Issue
Write user guides or review documentation/screenshots for release Website maintenance, Agent guide contract, release review Guide admission, missing/stale release review, publication gate
Align Desktop/Web controls, editing, confirmation and feedback Interaction guidelines, shared UI owners, production styles Interaction scenarios, same-state captures, UI quality
Select, execute or diagnose a build/test run Validation workflow, test map Selection, configured runner and revision-bound reports
Choose a website installer and follow platform setup Shared platform cards, installation page, navigation and copy interactions, website ownership Platform selection and history, bilingual guides
Deploy the website with a pending release catalog Website workflow, deployment decision, OSS deployment policy Pending catalog and stale build scenarios, OSS integrity checks
Qualify and publish macOS / Windows Desktop and Linux service/Web UI releases Release skill, release candidate entry, shared product version, build and publication guide, parallel package and validation jobs, candidate qualification Version lifecycle, development update selection, package-to-publication contract, Linux ABI gate, Windows Server native acceptance, installer identity and website publisher
Build, sign and qualify an Omarchy release package Actions workflow, native package producer, release admission and signing Subkey isolation and exact bytes, x86_64 KVM upgrade and Plan receipt, local ARM64 graphical smoke

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.