Yeachan-Heo/oh-my-codex
58.8
Adequate · 7 November 2026
210.1k
lines of production code
TypeScript
with Rust
4
measurements over time
What this system is
Features
Add OMX HUD idle CPU benchmark suite
A new benchmarking toolchain has been added to \scripts/bench-hud-cpu\ to measure and validate the idle CPU consumption of the HUD watcher. The suite includes a Dockerfile for reproducible Ubuntu-based testing, a \compare.sh\ script to run side-by-side baseline and fixed comparisons, and a \mac-cpu.mjs\ sampler for macOS host checks. It provides diagnostic instrumentation to track reconciliation children and tmux hook calls, allowing users to verify that fixes for idle CPU storms (such as avoiding reconciliation storms) effectively reduce resource usage.
scripts · high confidence
Add TypeScript declarations for tmux-hook-engine module
Added a new TypeScript declaration file (src/types/tmux-hook-engine.d.ts) that exposes the types and function signatures for the tmux-hook-engine module. This provides type safety for consumers of the module, covering configuration normalization, injection guard evaluation, pane state detection, and key-sending logic.
src/types · high confidence
Add capabilities lockfile preflight validation
A new capabilities lockfile mechanism has been introduced to validate the environment before execution. The system now generates a lockfile (\omx-capabilities.lock.json\) that captures digests of configured tools, skills, agents, and fixtures. During preflight checks, the system verifies that the current environment matches the lockfile, detecting issues such as missing lockfiles, schema drift in tool configurations, missing required arguments in observations, hallucinated tool calls, and unexpected tool calls. This ensures that the capabilities available to the system are consistent and valid before proceeding.
src/capabilities · high confidence
Add demo for latent noisy subspace discovery
A new interactive playground example has been added to demonstrate the discovery of latent subspaces in noisy optimization problems. This demo introduces a 32-dimensional objective function with a fixed latent mixing matrix, where the true signal lies in a lower-dimensional subspace. It showcases three distinct optimization strategies: a baseline random search, a CEM (Cross-Entropy Method) search, and a screened Bayesian GP approach that actively infers active dimensions to focus its search. Users can configure parameters such as budget, dimensionality, and acquisition function settings via a JSON config file to observe how these algorithms perform in high-dimensional, noisy environments.
_playground/bayesopt\_latent\_discovery\demo · high confidence
Add noisy high-dimensional Bayesian optimization demo
A new demo located at playground/bayesopt\_highdim\_demo introduces a 24-dimensional optimization problem with additive Gaussian noise (std 0.08) where only four specific dimensions (1, 5, 11, 17) are informative. The demo provides a configurable Bayesian optimization implementation using a Gaussian Process with a Matern kernel, supporting both random search and Bayesian GP strategies via a JSON configuration file. Users can run the demo via the command line to observe how the optimizer handles high-dimensional, noisy search spaces by focusing on the active subspace.
_playground/bayesopt\_highdim\demo · high confidence
Added adaptive sort benchmarking tool
A new Python script has been added to the playground to benchmark sorting algorithms. It implements a hybrid sorting strategy that dynamically selects between insertion sort, merge sort, and counting sort based on input size, value range, and sortedness metrics. The tool includes a configurable scoring system that weighs comparisons and moves, allowing users to evaluate algorithm performance against random, reverse, nearly-sorted, and duplicate-heavy datasets via a JSON configuration file.
python · high confidence
Document-refresh enforcement for native hooks and CLI behavior
A new document-refresh system has been added to automatically warn when source code changes require corresponding updates to documentation or planning specs. The system enforces rules for codex native hooks (src/scripts/codex-native-hook.ts, codex-native-pre-post.ts) and CLI operator behavior, ensuring that changes to these areas trigger warnings unless the relevant docs (e.g., docs/codex-native-hooks.md) or .omx/plans are also updated. This helps maintain documentation accuracy as the native hook and CLI features evolve.
src/scripts · high confidence
Introduce OpenClaw notification gateway integration
Adds a new OpenClaw integration that allows users to configure HTTP or CLI command gateways via the notifications.openclaw section of their config. The system maps specific hook events (session-start, session-end, session-idle, ask-user-question, stop) to these gateways, interpolating context variables like project path and session ID into instruction templates. It includes safe execution for command gateways (requiring explicit opt-in and clamped timeouts), HTTPS enforcement for HTTP gateways, and supports reply routing via environment variables to keep downstream interactions attached to the correct channel.
src/openclaw · high confidence
Introduce Ralplan Advisory mode with hardened state and evidence handling
Adds a new Ralplan Advisory mode that enforces strict lifecycle validation, durable state projections, and secure evidence boundaries. The change introduces a new advisory contract schema (version 1) defining activation, fence, journal, and admin event structures, alongside a dedicated advisory storage layer that ensures atomic writes and directory synchronization. It implements a new advisory activation verifier to validate pinned JSON state and file identity, and adds a documented leader preflight check to require a non-user-mintable root identity for adapted Ralplan operations. The update also includes lifecycle validation logic to ensure fence state semantics and journal steps are correctly applied, and introduces a detached transition validator to prevent cancellation if the journal session skill does not match the canonical writer's output.
src/ralplan · high confidence
Introduce Rust-based runtime core with authority, dispatch, and mailbox subsystems
The \omx-runtime-core\ crate now provides the foundational runtime logic in Rust, replacing the previous JavaScript bridge with a thin interface. This change introduces a \RuntimeEngine\ that manages authority leases (acquire, renew, release), a dispatch log for tracking request lifecycle (pending, notified, delivered, failed), and a mailbox log for inter-worker messaging. It also includes replay state for deduplicating events and deferring leader notifications, along with utility functions to classify dispatch outcomes based on target availability and send confirmation.
crates/omx-runtime-core · high confidence
Introduce base mode lifecycle management for oh-my-codex
Added a new \src/modes/base.ts\ file that establishes the shared lifecycle management for all execution modes (including autopilot, autoresearch, deep-interview, ralph, ultrawork, team, ultraqa, ultragoal, and ralplan). This component centralizes mode state normalization, validates deprecated mode names (ultrapilot, pipeline, ecomode) with deprecation warnings, and enforces state contracts for run outcomes and handoff carriers. It also introduces specific logic for Ralplan advisory start profiles and autopilot completion advisories, ensuring consistent state handling across the CLI's various operational modes.
src/modes · high confidence
Introduce extensible hook plugin system with runtime, dispatcher, and SDK
Users can now extend the application via a new hook plugin system located in src/hooks/extensibility. This change adds a runtime dispatcher that discovers, validates, and executes external .mjs plugins from the .omx/hooks directory, supporting both native and derived events with configurable timeouts and side-effect controls. It provides a plugin SDK offering tmux interaction, persistent state management, structured logging, and read-only access to OMX session/HUD state, while ensuring reliable process lifecycle management and deduplication of lifecycle broadcasts.
src/hooks/extensibility · high confidence
Introduce native asset archive inspection and release manifest validation
Added new modules in src/native-assets to safely inspect native asset archives (tar.xz, tar.gz, zip) and validate release manifests. The archive inspection logic normalizes paths, detects path traversal or prefix collisions, and streams individual members without extracting the entire archive. The policy module enforces strict validation on release manifests, including version/tag consistency, SHA-256 integrity checks, platform/architecture/libc target mapping, binary name/path correctness, and URL/basename alignment, ensuring only verified and correctly structured native assets are accepted.
src/native-assets · high confidence
Introduce native plugin hook infrastructure for the Oh-My-Codex plugin
The Oh-My-Codex plugin now includes a native hook system defined in \hooks.json\ and implemented in \codex-native-hook.mjs\. This adds a new command-line hook that executes the native Node.js script for key lifecycle events, including SessionStart, PreToolUse, PostToolUse, UserPromptSubmit, PreCompact, PostCompact, SubagentStop, and Stop. The implementation handles JSON payload parsing, event detection, and session routing, providing a robust foundation for plugin interactions within the Codex environment.
plugins/oh-my-codex/hooks · high confidence
Introduce new Rust-greenfield HUD implementation with tmux authority and reconciliation
The HUD module has been rewritten from scratch (replacing the previous JS-based implementation) to provide a more robust, authoritative statusline. This new implementation introduces a strict tmux-based authority model where a single leader pane owns HUD mutations, preventing duplicate panes and race conditions during prompt submission or team layout changes. It adds a dedicated authority tick process that manages state files with atomic writes and cooldowns, ensuring stable ownership across session revivals and leader pane swaps. The HUD now features a two-layer architecture with a dedicated reconcile loop that repairs orphaned, stale, or duplicate HUD panes, and a watch mode that intelligently skips rendering work when no tmux client is attached to save CPU. It also includes new rendering capabilities for Guardex finish progress, Ralph iteration status with color-coded thresholds, and team worker visibility, all while hardening against shell injection and terminal escape injection in dynamic text.
src/hud · high confidence
Introduce oh-my-codex hook infrastructure and skill routing
Added a new set of hooks in src/hooks to support the oh-my-codex multi-agent orchestration. This includes a keyword detection engine and registry for routing commands to specific skills (e.g., $deep-interview, $ultragoal, $plan), a codebase map generator for efficient context injection, and an agents-overlay module to dynamically manage AGENTS.md content. The update also introduces session provenance tracking, prompt guidance contracts, and a sunset-stub system to handle deprecated skills like $ralph and $pipeline.
src/hooks · high confidence
Introduce oh-my-codex multi-agent orchestration package
The src directory now exports the new oh-my-codex package, providing a multi-agent orchestration layer for the Codex CLI. This includes specialized agent prompts, workflow skills, and an orchestration brain, exposed via CLI commands for setup, diagnostics, and versioning. The package also integrates with VS Code by exposing functions to resolve launch environments, handle dangerous approval checks, and manage direct sessions, alongside a HUD statusline command and native agent configuration generation.
src · high confidence
Introduce omx-api crate with local real generation support
The new omx-api crate provides a local API server and CLI that supports a 'real-private' backend mode, allowing local real generation compatibility by proxying requests to a private upstream while preserving response metadata. It includes a daemonized server with state management, telemetry, and CLI commands for system checks and generation, along with end-to-end tests to ensure reliability under load and proper resource cleanup.
crates/omx-api · high confidence
Introduce omx-runtime binary with lease-mutex and atomic file operations
The \omx-runtime\ crate now provides a standalone binary that manages runtime state persistence and offers low-level system utilities. It introduces a \lease-mutex\ subcommand that uses native OS mutexes to serialize canonical mode binding leases, ensuring safe concurrent access to state directories. The runtime also includes \fs-rename-no-replace\ for atomic file moves (using \SYS\_renameat2\ on Linux) and \process-identity\ for cross-platform process identification, alongside standard commands for schema inspection, snapshotting, and executing runtime mutations with exclusive locking.
crates/omx-runtime/src · high confidence
Introduce passive URL reader with safe fetching and truncation controls
Added a new \url-reader\ module that fetches URLs and extracts titles and snippets while enforcing safety and resource limits. The reader blocks unsafe targets (localhost, loopback IPs, unsupported protocols) and challenge responses (e.g., Cloudflare), handles redirects with a configurable limit, and caps body reads via \maxBytes\ to prevent excessive memory usage. It also fixes a truncation edge case so that a complete body matching the byte limit is not incorrectly marked as truncated, and ensures error details are returned without stack traces.
src/url-reader · high confidence
Introduce performance goal workflow with state management and validation
Added a new performance goal workflow that manages the lifecycle of performance objectives through a structured state file, an append-only ledger, and a markdown-based evaluator contract. Users can now create goals with specific evaluation commands and pass/fail contracts, which are persisted in the \.omx/goals/performance\ directory. The system tracks status transitions (created, in\_progress, validation\_passed/failed, blocked, complete) and requires concrete evidence for validation steps before a goal can be marked as complete, ensuring that performance criteria are explicitly verified.
src/performance-goal · high confidence
Introduce sandboxed explore harness with allowlist and fallback logic
The \omx-explore\ crate now includes a new Rust-based harness (\main.rs\) that manages the execution of the Codex model. This harness introduces a strict allowlist of direct commands (such as \rg\, \grep\, \ls\) and shell wrappers to restrict tool access, while also enforcing process limits, output size caps, and timeouts to prevent resource exhaustion. It implements a fallback mechanism that attempts a primary model (spark) and automatically retries with a secondary model if the first fails, ensuring robustness. The harness also scrubs potentially dangerous environment variables and handles platform-specific constraints, such as failing closed on Windows where POSIX wrappers are unsupported.
crates/omx-explore · high confidence
Introduce structured agent role definitions and native configuration generation
The system now defines agent roles via a structured schema in \src/agents/definitions.ts\, specifying attributes such as reasoning effort, posture (frontier-orchestrator, deep-worker, fast-lane), model class, and tool access patterns for roles like executor, planner, and various reviewers. Corresponding logic in \src/agents/native-config.ts\ uses these definitions to generate standalone TOML configuration files for the Codex CLI, applying posture-specific instructions and model overrides (e.g., pinning the planner to \gpt-6-astra\). Policy rules in \src/agents/policy.ts\ enforce catalog integrity by validating canonical targets for native agents and filtering installable agents based on their status.
src/agents · high confidence
Introduce team orchestration runtime and allocation policies
This change adds the core team orchestration runtime to \src/team\, introducing new files that define the team API interop layer, task allocation policies, commit hygiene, and coordination protocols. The allocation policy (\allocation-policy.ts\) implements a scoring system to assign tasks to workers based on role, file paths, and domain hints, while the coordination protocol (\coordination-protocol.ts\) synthesizes plans for task dependencies and interdependence. The API interop layer (\api-interop.ts\) exposes a comprehensive set of team operations (e.g., task creation, claim, transition, mailbox management) and replaces legacy MCP tools. Additionally, new modules handle approved execution bindings, current task baselines, DAG schema parsing, delegation policies, and delivery logging, establishing the foundational contracts and state management for multi-worker team execution.
src/team · high confidence
Introduce the Oh My Codex VS Code extension
The repository now includes a new VS Code extension that provides a local Chat surface for launching and resuming direct OMX sessions, streaming session output, and managing local chat transcripts. Users can start and stop sessions, run the \omx doctor\ health check, and open recent logs directly from the extension's webview. The extension stores conversation state in the workspace's \.omx/vscode/conversations/\ directory and requires the OMX core API to be built at the repository root before it can be installed locally.
packages/vscode-extension · high confidence
Introduces Ultragoal artifact schema and steering invariants
Adds the \src/ultragoal/artifacts.ts\ module, which defines the core data structures for the Ultragoal system. This includes the \UltragoalPlan\, \UltragoalItem\, and \UltragoalLedgerEntry\ interfaces that model goal states, statuses (such as \review\_blocked\ and \needs\_user\_decision\), and lifecycle events. It also introduces the \UltragoalSteeringProposal\ and \UltragoalSteeringAudit\ types, enabling audited goal modifications (like adding subgoals or splitting tasks) and enforcing architectural invariants before accepting changes. This file establishes the persistent schema and validation logic for Ultragoal state management.
src/ultragoal · high confidence
Introduces durable goal-workflow artifacts and strict Codex snapshot reconciliation
This change adds a new goal-workflow subsystem under src/goal-workflows that persists workflow state in .omx/goals via status.json and a JSONL ledger, enforcing a strict completion path where a goal cannot transition to 'complete' without a passing validation artifact (rejecting placeholders and missing paths). It also introduces Codex goal snapshot parsing and reconciliation that preserves native 'blocked' status, treats null get\_goal results as no active goal (preventing false completions), and distinguishes database/schema errors from normal missing goals, ensuring handoffs and audits rely on real evidence rather than mutable hidden state.
src/goal-workflows · high confidence
Introduces leader conductor contract and native subagent support detection
Adds the \src/leader/contract.ts\ module and its test suite to define the Main-root Conductor mode contract, including the Golden Rule (Main orchestrates while delegated lanes implement) and Silver Rule (reuse/resume agents). It implements logic to detect native subagent support status from runtime capabilities and tool inventories, handling cases where support is explicitly unavailable, supported, or unknown. The module also provides guidance blocks for degraded states, such as when native role routing is unavailable or native subagents are unsupported, ensuring the system fails closed with appropriate recovery paths rather than misparsing permissions or capabilities.
src/leader · high confidence
Native subagent tracking and role-routing markers
Added a new native subagent tracking system and role-routing marker mechanism to manage subagent lifecycle and routing state. The new \tracker.ts\ module introduces a file-based store (\subagent-tracking.json\) that records subagent sessions, threads, and availability status, including explicit reopen authority checks to prevent unauthorized session reopens. The new \role-routing-marker.ts\ module provides a cross-process-safe, expiring marker store (\native-subagent-role-routing.json\) to track when role routing is unavailable for specific sessions and scopes, ensuring that subagents respect authority boundaries and routing constraints.
src/subagents · high confidence
New MCP servers for code intelligence, memory, traces, and wiki knowledge
The \src/mcp\ area now includes several new MCP server implementations that expose project-level capabilities to external clients. The new \code-intel-server\ provides LSP-like diagnostics (via \tsc\), symbol extraction, and AST pattern matching (via \ast-grep\). The \memory-server\ introduces persistent project memory and session notepad tools for storing and retrieving structured notes and directives. The \trace-server\ exposes agent flow debugging by reading turn-based JSONL logs and mode lifecycle events. The \wiki-server\ adds a local knowledge layer for ingesting, querying, and managing structured wiki pages. These servers are bootstrapped via the new \bootstrap.ts\ lifecycle manager, which handles stdio transport, sibling deduplication, and telemetry logging.
src/mcp · high confidence
New ML Kaggle demo with configurable model training
The playground/ml\_kaggle\_demo area now includes a complete, runnable machine learning demonstration. Users can train models on the Breast Cancer dataset using a factory pattern that supports Decision Trees, Random Forests, Extra Trees, HistGradientBoosting, and Logistic Regression (with scaling). The model and its hyperparameters are configured via a new config.json file, and the training script outputs JSON metrics including ROC AUC and accuracy.
_playground/ml\_kaggle\demo · high confidence
New auth subsystem with hot-swap, rotation, and redaction
The \src/auth\ directory now contains a complete authentication management layer. It introduces auth slot hot-swapping to switch credentials without restarting the process, automatic quota-based rotation (round-robin, priority, or manual) to handle rate limits, and a robust stderr redactor that safely masks tokens even across oversized or split records. The system also includes atomic storage with file locking to prevent corruption during concurrent access, and config merging that respects project-level overrides over user-level defaults.
src/auth · high confidence
New code-simplifier stop hook for automatic refactoring
Adds a new code-simplifier hook that automatically detects recently modified source files and delegates them to a code-simplifier agent for cleanup. The feature is opt-in via \~/.omx/config.json (enabled: true) and includes logic to manage trigger markers, filter files by extension and count, and handle git status changes including untracked files.
src/hooks/code-simplifier · high confidence
New configuration subsystem for Codex hooks, models, and team mode
The \src/config\ directory now contains a dedicated configuration subsystem that manages Codex CLI feature flags (including legacy \codex\_hooks\ support), managed hook lifecycle and trust state, and Windows-native hook shims. It introduces a shared MCP registry loader to sync servers into both Codex and Claude settings, and adds a TOML generator that merges these entries while preserving user-owned keys like \notify\ and \model\_reasoning\_effort\. Model resolution is centralized with support for per-agent reasoning overrides and environment-based defaults, while team mode and deep-interview profiles are now explicitly configurable via \.omx-config.json\ and environment variables.
src/config · high confidence
New evaluation harness and scripts for Astra/Luna/GPT-6.1 cost and quality metrics
The \src/scripts/eval\ directory now includes a comprehensive set of new evaluation scripts to support live and deterministic testing of the Astra/Luna/GPT-6.1 models via Layofflabs. The primary addition is \collect-astra-defaults.ts\, a live collector runner that executes evaluation suites, records performance metrics (latency, pass/fail status), and outputs structured JSON reports. This is complemented by \eval-astra-defaults.ts\, which handles deterministic baseline comparisons and report rendering. Additional scripts have been added to evaluate specific optimization and security scenarios, including adaptive sort optimization, ML model optimization (Kaggle), noisy Bayesian optimization, and security path-traversal checks. These scripts collectively provide a new, automated way to measure and report on model cost, quality, and security compliance.
src/scripts/eval · high confidence
New evaluation harness for Astra default model cost and quality
The \src/evals/astra-defaults\ directory now contains a complete evaluation suite for measuring the cost and quality of default model configurations. This includes a collector that clones the OMX repository, executes the Codex CLI against task fixtures, and captures latency, token usage, and response checks. The suite supports custom providers (such as Layofflabs) and validates all run records against strict schemas to ensure data integrity. Reports can be generated showing per-task results, aggregate configuration summaries, and workload-weighted pass rates, with clear separation between model usage costs and operator effort.
src/evals/astra-defaults · high confidence
New extensibility SDK for hook plugins
The extensibility SDK now provides a structured API for hook plugins to manage persistent state, interact with the terminal via tmux, and log activity. Plugins can read, write, and delete key-value pairs stored in JSON files under the plugin's state directory. The SDK exposes tmux capabilities to send keys to specific panes or sessions, including logic to resolve the correct Codex pane and safeguards against infinite loops or duplicate key injections. Additionally, a logging utility allows plugins to append structured JSON lines to daily log files, aiding in debugging and monitoring plugin behavior.
src/hooks/extensibility/sdk · high confidence
New multi-platform notification system with throttling and custom templates
The notifications module has been replaced with a new system that sends lifecycle alerts (session start, stop, end, idle) to Discord (webhooks and bots), Telegram, Slack, and generic webhooks. It introduces dispatch and idle cooldowns to prevent notification flooding, configurable via environment variables or .omx-config.json, and adds a hook template engine allowing users to customize message formats per event and platform. The system also includes a lifecycle deduplication mechanism to suppress duplicate broadcasts within a short window and validates platform-specific credentials and URLs before sending.
src/notifications · high confidence
New omx adapt CLI command and capabilities lockfile preflight
The CLI now includes an \omx adapt\ command with subcommands (probe, status, init, envelope, doctor) for managing adapter foundations for targets like OpenClaw and Hermes. Additionally, a capabilities lockfile system has been introduced to validate tool contracts, skills, and agents before execution, ensuring that observed tool usage matches expected schemas and preventing hallucinated or unauthorized tool calls.
src/cli · high confidence
New opt-in Herdr lifecycle/status bridge and persistent adapter foundation
The adapt subsystem now includes a persistent adapter foundation that resolves and writes OMX-owned configuration and envelope artifacts under \.omx/adapters/\<target\>\ for OpenClaw, Hermes, and the newly added Herdr target. For Herdr, an opt-in lifecycle and status bridge is introduced: when OMX runs inside a Herdr pane (detected via \HERDR\_ENV\ and \HERDR\_PANE\_ID\), it maps internal events to Herdr semantic states (working, blocked, idle, unknown) using monotonic sequence ordering and authority release, with best-effort, non-blocking reporting via CLI or Unix socket transports. Hermes adapter discovery now honors a supplied working directory for programmatic probes, and both Hermes and OpenClaw reports include runtime evidence and asymmetric capability ownership (omx-owned, shared-contract, target-observed). Adapter init writes are gated behind an explicit \--write\ flag and are confined to adapter-owned paths, while inherited adapt registry targets are rejected during validation.
src/adapt · high confidence
New planning artifact parsing and markdown visibility scanning
Added new modules in src/planning to handle planning artifact file naming conventions and markdown content visibility. The artifact-names module introduces timestamped file naming for PRDs, test specs, and deep interviews, enabling precise matching and sorting of these artifacts. The artifacts module provides functions to read and select planning artifacts from the .omx directory structure. The markdown-structure module implements a state machine for scanning markdown files to identify visible text while correctly handling fenced code blocks, indented code, and HTML comments, which is used to extract relevant content from planning documents.
src/planning · high confidence
New session history diagnostics and export capabilities
This change introduces four new local session-history capabilities: exporting session transcripts to Markdown or JSON (with optional tool-call inclusion and privacy-safe media placeholders), searching session history by query with project/session/time filters, generating cumulative token-usage reports, and building execution timelines with tool diagnostics. It also adds a local session-friction report that summarizes metadata-only signals (idle gaps, stale sessions, parse gaps) without exposing raw transcript content.
src/session-history · high confidence
New sidecar CLI for reading team state and rendering terminal views
This change introduces the \omx sidecar\ command, which reads team state from disk and renders a read-only, sanitized terminal view of the team's topology, workers, tasks, and events. It supports \--json\ for machine-readable snapshots, \--watch\ for live terminal updates, and \--tmux\ to open a dedicated right-side pane. The implementation includes argument parsing that correctly handles missing flag values, a collector that normalizes legacy and v2 config formats without mutating files, and a renderer that sanitizes control characters to prevent terminal injection.
src/sidecar · high confidence
New utility modules for AGENTS.md management, TOML parsing, and platform-specific path/command resolution
This change introduces a suite of new utility modules in src/utils that support the multi-agent orchestration and setup workflows. agents-md.ts and agents-model-table.ts provide the logic for generating, parsing, and preserving the AGENTS.md operating contract, including user policy blocks and the auto-generated model capability table. toml.ts and toml-source.ts add robust, line-aware TOML reading and writing that respects multiline strings and table boundaries. paths.ts and package.ts handle Codex home, config, and package root resolution in an ESM-safe manner. platform-command.ts implements cross-platform command discovery and spawning with specific handling for Windows extensions and POSIX PATH edge cases. file-durability.ts ensures file syncs on Windows tolerate EPERM errors without crashing. git-layout.ts and worktree-tool-context.ts resolve Git worktree structures and configure shared/local CodeGraph modes. Finally, repo-deps.ts bootstraps reusable node\_modules in worktrees, while safe-json.ts and sleep.ts provide basic safety and timing helpers.
src/utils · high confidence
New verification protocol for runtime completion gating
Added a new verification module that enables evidence-backed verification of task completion. This includes logic to detect structured verification evidence in task summaries, generate specific verification instructions based on task size (small, standard, large), determine task size from file and line changes, and provide instructions for a fix-verify loop. This module supports runtime completion gates by ensuring tasks are properly verified before being marked complete.
src/verification · high confidence
Structured deep-interview questioning with autopilot gating and event tracking
The question subsystem now supports structured, multi-step deep-interview workflows where the autopilot is explicitly blocked from proceeding until an operator answers a series of questions. This change introduces a new enforcement model: the system creates binding obligations that pause autopilot execution, enforces these pauses via file-based locking to prevent race conditions, and emits structured lifecycle events (created, answered) for observability. It also adds a policy layer that prevents questions from running in worker or team contexts, and introduces a new CLI client for executing questions programmatically. The UI has been updated to handle multi-question wizards with inline 'Other' text collection, ensuring a cohesive blocking experience for the operator.
src/question · high confidence
Architecture
State module refactored into a single-writer architecture with native lease locking
The state management layer has been restructured to enforce a strict single-writer invariant for workflow-mode projections, routing all durable state writes through a central \writeStateFile\ primitive in \operations.ts\. This change introduces native OS-level lease locking via \mode-binding-lease.ts\ and \mode-binding-lease-helper.ts\ to prevent race conditions and ensure canonical state ownership. Additionally, a new \handoff-carrier.ts\ module validates and rejects malformed handoff artifacts to prevent forged evidence from advancing Autopilot phases, while \namespace-owners.ts\ explicitly declares ownership for non-workflow namespaces (such as HUD, team, and lifecycle hooks) to maintain auditability. The \mode-state-context.ts\ module now captures precise tmux pane bindings for Ralph activation, ensuring session-scoped runtime state is correctly attributed.
src/state · high confidence
Behavioural changes
1 commit (0 fixes) modifying src/bin, src/quality-gates
A change to existing behaviour in src/bin, src/quality-gates — 1 commit, 3 files: “feat(\#3955): Add configurable custom quality gates via .omx-config (\#3956)” (refs \#3955, \#3956).
src/bin, src/quality-gates · medium confidence · unverified
2 commits (1 fix) modifying src/vscode
A change to existing behaviour in src/vscode — 2 commits (1 fix), 2 files: “fix(vscode): use platform command launcher (\#2856)”; “test: wait for VSCode log stream completion (\#3937)” (refs \#2856, \#3937).
src/vscode · medium confidence · unverified
Audited follow-up queues for interrupted exec and imagegen jobs
Users can now resume interrupted workflows with full auditability. The system introduces a persistent follow-up queue (stored in \.omx/state/sessions/\<id\>/exec-followups.json\) that records prompts, actors, and timestamps for execution jobs, ensuring these actions are logged to \.omx/logs/exec-followups-\*.jsonl\. This mechanism is specifically leveraged by the new imagegen continuation feature to automatically queue a resume instruction when an image generation is interrupted, allowing the system to recover the visual workflow while maintaining a verifiable record of the recovery action.
src/exec · high confidence
Autopilot planning routing and completion gate enforcement
The Autopilot system now intelligently routes planning tasks: if the main model is a cheap or mini variant, or if an explicit planner override is configured, planning is delegated to a dedicated planner agent to preserve quality. Additionally, a new completion gate (\completion-gate.ts\) enforces strict invariants on handoff evidence and artifact paths, ensuring that only canonical, non-forged evidence is accepted during phase transitions, while remaining visible as advisory if evidence is simply missing.
src/autopilot · high confidence
Autoresearch now uses a validator-gated skill loop with goal-mode handoffs
The autoresearch feature has been refactored to replace legacy launch paths with a new validator-gated skill loop. This change introduces a structured goal system (src/autoresearch/goal.ts) that manages mission lifecycles, ledgering, and completion verdicts, while integrating with goal-workflow snapshot reconciliation to protect goal workflows. The runtime (src/autoresearch/runtime.ts) and contracts (src/autoresearch/contracts.ts) now enforce stricter sandbox parsing, require JSON evaluator output, and support a 'keep\_policy' to control candidate retention. Additionally, skill validation (src/autoresearch/skill-validation.ts) determines completion based on either a mission-validator script or prompt-architect artifact approval, ensuring that autoresearch runs stop after repeated noops and that completed goals are explicitly cleaned up.
src/autoresearch · high confidence
Explicit retirement of stale 0.20.x state projections during upgrade
The upgrade path from version 0.20.x to 0.21 now requires an explicit operator action to handle stale state projections, replacing the previous automatic launch-time neutralizer. Users must now use the \omx doctor --repair-state\ command to archive stale projections into \.omx/archive/\ rather than having them silently rewritten or terminalized in place. This change ensures that valid current active runs are preserved and that state migration is a deliberate, auditable step rather than an implicit background process.
src/compat · high confidence
Introduce Rust-based tmux mux adapter and runtime contract
The \omx-mux\ crate now provides a Rust implementation for the terminal multiplexer runtime contract, replacing the previous JavaScript bridge with a thin adapter layer. This change introduces a \TmuxAdapter\ that executes operations (resolve-target, send-input, capture-tail, inspect-liveness, attach, detach) by invoking the \tmux\ CLI directly. It defines the core data types (\MuxOperation\, \MuxTarget\, \InputEnvelope\, \SubmitPolicy\) and enforces a canonical contract summary, ensuring that input normalization (e.g., newline handling) and submission policies are managed within the Rust runtime rather than the JS layer.
crates/omx-mux · high confidence
Introduce omx-sparkshell Rust CLI for command summarization and telemetry
The omx-sparkshell tool is now implemented in Rust, providing a native CLI that executes commands (or captures tmux panes) and automatically summarizes lengthy output using a local AI API (defaulting to the gpt-6-astra model). It features built-in secret redaction to prevent sensitive data from reaching the summarization service, supports a fallback model for API reliability, and includes a command-family registry to tailor prompts for tools like git, cargo, npm, and others. The tool also adds incremental cache support for pane observations and exposes structured JSON reports for automation.
crates/omx-sparkshell/src · high confidence
Introduce structured skill catalog and visual-verdict feedback loop
The system now uses a validated JSON manifest in src/catalog to define skills and agents, enforcing strict statuses (active, deprecated, alias, merged) and requiring canonical targets for aliases and merged entries to prevent broken references. This catalog is read via src/catalog/reader.ts and exposed through a public contract, while src/catalog/installable.ts controls which skills are available during setup. Additionally, src/visual/verdict.ts introduces a structured feedback loop for the Visual Ralph workflow, validating scores, verdicts, and suggestions to produce concrete next actions for design iterations.
src/catalog · high confidence
Native hooks now use advisory PreToolUse and warn about tmux limitations
The native hook implementation has been simplified to remove hard workflow gates, making PreToolUse decisions advisory rather than blocking for ordinary tasks. Users will now see capability warnings when using Codex App or native Bash outside a tmux session, clarifying that team features, the HUD runtime, and specific question pane targeting require an attached tmux shell. While most restrictions are lifted to allow ordinary paths to continue, the system retains the ability to deny specific authority-decreasing actions, such as session cancellations, to prevent conflicts.
src/hooks/native · high confidence
Ralph completion audit and state validation
Ralph now enforces stricter lifecycle invariants and completion criteria. A new completion audit mechanism (src/ralph/completion-audit.ts) requires passing visual-verdict feedback and substantive verification evidence (checklists, tests, or commands) before a run is considered complete. State validation (src/ralph/contract.ts) normalizes phase names, enforces integer iteration counters, and ensures terminal phases are inactive. Persistence (src/ralph/persistence.ts) introduces a canonical progress ledger with schema versioning and migrates legacy PRD/progress files.
src/ralph · high confidence
Rewrite notify-hook in TypeScript with Rust runtime bridge and team coordination
The notify-hook script has been rewritten in TypeScript, introducing structured modules for team dispatch, leader nudges, and auto-nudges. Team dispatch now routes state transitions through a Rust runtime binary (with a JSON fallback), while leader nudges and auto-nudges use session-scoped state and tmux pane guards to prevent stale or duplicate injections. The rewrite also adds structured event logging, managed tmux session resolution, and orchestration intent tagging to improve reliability and observability.
src/scripts/notify-hook · high confidence
Team state logic restructured into modular, audited components
The team state management logic has been reorganized from a monolithic structure into distinct, focused modules (approvals, dispatch, events, locks, mailbox, monitor, tasks, workers, config, and shutdown). This change introduces granular, audited state transitions for task claims and mailbox deliveries, enforces delegation compliance evidence for team tasks, and adds robust, lease-based file locking for scaling and membership operations to prevent race conditions. Users benefit from more reliable team orchestration, clearer state persistence, and improved observability of worker and task lifecycle events.
src/team/state · high confidence
Fixes
New Rust-backed runtime bridge and unified lifecycle outcome handling
The runtime now communicates with the Rust \omx-runtime\ binary via a new bridge (\src/runtime/bridge.ts\) that resolves the native binary from the verified cache (supporting macOS arm64 npm installs) and validates its integrity via SHA-256 sidecar files. Process spawning is handled by a new \process-tree\ module that enforces \windowsHide\ on Windows, limits output size, and manages process-tree termination. To ensure consistent state across the system, a new \run-outcome\ and \run-state\ layer normalizes legacy and canonical run/lifecycle outcomes, preserving explicit results during state syncs and preventing false coordination signals or resource leaks during team dispatch and mailbox transitions.
src/runtime · high confidence
Test coverage
Add CLI test coverage for new and existing commands; Added compatibility and upgrade regression tests; Added comprehensive test coverage for MCP server bootstrap, lifecycle, and state tools; Added comprehensive test coverage for Ultragoal artifacts, documentation contracts, and steering logic; Added comprehensive test coverage for team orchestration and runtime contracts; Added comprehensive test coverage for the HUD module; Added comprehensive test coverage for the notification subsystem; Added comprehensive tests for state authority, handoff, and persistence invariants; Added integration tests for modes/base state management and contract validation; Added test coverage for OpenClaw configuration, gateway dispatching, and public API; Added test coverage for config module internals; Added test coverage for the question subsystem; Added tests for Autopilot completion gates, FSM helpers, and planner routing; Added tests for Ralplan advisory lifecycle and evidence integrity; Added tests for SparkShell execution and command-family registry; Added tests for agent definitions and native configuration generation; Added tests for approved execution lifecycle and planning artifacts; Added tests for autoresearch contracts, runtime, and skill validation; Added tests for catalog manifest validation and plugin bundle synchronization; Added tests for completion audit validation and persistence migration; Added tests for lease mutex serialization and schema subcommands; Added tests for notify-hook operational events, payload guards, and team worker PostToolUse handling; Added tests for runtime binary resolution, process tree management, and run outcome contracts; Added tests for subagent tracking and leader bootstrap logic; Added tests for the Astra Defaults evaluation collector, reporting, and suite validation; Added unit tests for the hook extensibility runtime and plugin infrastructure; Added unit tests for utility modules; Added verification tests for CI workflows, release artifacts, and verification logic; Comprehensive test suite for the new wiki module; Expanded test coverage for hook contracts, skills, and runtime behaviors; Expanded test coverage for native hook cancellation and system integrity.
Dependencies
Initial dependency manifests and lockfiles for the OMX workspace
The repository now includes the foundational dependency configuration for the multi-agent orchestration layer. This adds a Rust workspace (Cargo.toml/Cargo.lock) defining the \omx-api\, \omx-explore-harness\, \omx-mux\, \omx-runtime-core\, \omx-runtime\, and \omx-sparkshell\ crates, alongside a Node.js manifest (package.json/package-lock.json) pinning the \omx\ CLI and its dependencies like \@modelcontextprotocol/sdk\ and \zod\. A VSCode extension manifest is also included to provide a UI for launching and monitoring sessions.
(dependencies) · high confidence
Housekeeping
Internal planning and release-prep artifacts for 0.18.13
This change adds internal planning documents and release-prep artifacts for version 0.18.13. It includes a new plan outlining the session-authoritative HUD/state/session reconciliation architecture, along with ultragoal brief, goals, and ledger files that record the release scope decision, artifact preparation, verification, and handoff steps. These files are process and planning records; they do not contain product code changes or user-facing behavior modifications.
.gjc · 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
This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.
Score
- CAI 55 → 59 (+4.2)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 48 → 48 (-0.3)
- Architecture 75 → 74 (-1.5)
- Maturity 51 → 83 (+31.8)
- Readiness 73 → 73 (+0.2)
- Security 73 → 73 (+0.1)
- Event Sourcing 100 → 100 (+0.0)
- Performance 60 → 60 (+0.0)
Resolved (38)
- Documentation: no installation or build instructions (docs/index.html)
- Documentation: no project overview (docs/index.html)
- FunctionTooLong: runtime.monitorTeam (src/team/runtime.ts)
- Further sole-owners (lower concentration)
- Hotspot: src/cli/sparkshell.ts (src/cli/sparkshell.ts)
- Hotspot: src/cli/uninstall.ts (src/cli/uninstall.ts)
- Hotspot: src/mcp/state-paths.ts (src/mcp/state-paths.ts)
- Hotspot: src/state/skill-active.ts (src/state/skill-active.ts)
- Hotspot: src/subagents/tracker.ts (src/subagents/tracker.ts)
- Low CVE: [CVE redacted] (package-lock.json)
- Medium CVE: [CVE redacted] (package-lock.json)
- Medium IaC: CKV_DOCKER_9 (scripts/bench-hud-cpu/Dockerfile)
- Medium: security finding (details withheld)
- Medium: security finding (details withheld)
- Medium: security finding (details withheld)
- Medium: security finding (details withheld)
- Medium: security finding (details withheld)
- Medium: security finding (details withheld)
- Medium: security finding (details withheld)
- Medium: security finding (details withheld)
- …and 18 more
New (57)
- Classify ADR enforcement: ADR 3194: Documented leader proof for exact reviewed Codex releases (docs/adr/3194-codex-01445-documented-leader-proof.md)
- Classify ADR enforcement: ADR 3212: Same-user native-child authentication boundary (docs/adr/3212-same-user-native-child-auth-boundary.md)
- Classify ADR enforcement: ADR 3459: Preserve the Team source-authority tmux argv separator boundary (docs/adr/3459-team-tmux-argv-separator-boundary.md)
- FileTooLong: team/worktree.ts (src/team/worktree.ts)
- High CVE: [GHSA redacted] (package-lock.json)
- High CVE: [GHSA redacted] (package.json)
- Hotspot: src/team/api-interop.ts (src/team/api-interop.ts)
- Hotspot: src/team/worktree.ts (src/team/worktree.ts)
- Medium CVE: [GHSA redacted] (package-lock.json)
- Medium CVE: [GHSA redacted] (package-lock.json)
- Medium CVE: [GHSA redacted] (package-lock.json)
- Skipped (documented): forwards payload, stdout, stderr, and non-zero exit through the Windows shim when PowerShell is available (src/config/tests/codex-hooks.test.ts)
- Skipped (documented): reads named and inferred team status under an actual read-only filesystem (src/cli/tests/team-status-readonly.test.ts)
- codex-goal-snapshot.unwrapNativeGoalResponse (cognitive 28) (src/goal-workflows/codex-goal-snapshot.ts)
- dispatch.enqueueDispatchRequest (cognitive 17) (src/team/state/dispatch.ts)
- dispatch.enqueueDispatchRequest (cyclomatic 16) (src/team/state/dispatch.ts)
- doc comments repeat the names (src/agents/definitions.ts)
- doctor.checkStateRootSessionBinding (cyclomatic 19) (src/cli/doctor.ts)
- quality-gates.normalizeGateEntry (cognitive 18) (src/config/quality-gates.ts)
- quality-gates.readQualityGatesConfig (cognitive 47) (src/config/quality-gates.ts)
- …and 37 more
Changes since last survey
- 159 commits — 113 feature/other, 46 fixes
By area
- (repo) — 50 commits
- (root) — 38 commits
- src/cli — 33 commits
- docs/qa — 16 commits
- src/team — 15 commits
- src/scripts — 2 commits
- .github/workflows — 1 commit
- docs/reference — 1 commit
- plugins/oh-my-codex — 1 commit
- src/config — 1 commit
- src/vscode — 1 commit
Notable commits
- fix: Fix dispatch read failure and test hook timing issues (#3883)
- fix: Merge branch 'release/omx-0.21.31' of https://github.com/Yeachan-Heo/oh-my-codex into release/omx-0.21.31-fix
- fix: Merge pull request #3890 from Yeachan-Heo/fix/setup-scope-realpath-0.21.32
- fix: Merge pull request #3959 from Yeachan-Heo/fix/history-ctime-check
- fix: fix(doctor): remove setup as native cache repair (#3971)
- fix: fix(history): detect same-mtime content mutations
- fix: fix(history): detect same-mtime content mutations
- fix: fix(native-hook): route CLI error logs through omxLogsDir (#3908) (#3909)
- fix: fix(plugin-cache): distinguish claim digest diagnostics (#3921) (#3923)
- fix: fix(session): don't let a managed Codex daemon own the OMX session pointer (#3946) (#3949)
- fix: fix(setup): Windows path sanitization and test fixes
- fix: fix(setup): address Codex findings for path canonicalization and scope validation
- fix: fix(setup): address all three Codex findings
- fix: fix(setup): address remaining Codex findings for symlink validation
- fix: fix(setup): address symlink detection and scope validation issues
- fix: fix(setup): allow OS-level symlinks in scope root ancestors
- fix: fix(setup): canonicalize scope roots to fix symlink path comparison
- fix: fix(setup): detect dangling symlinks before canonicalization (4353639282)
- fix: fix(setup): migrate legacy skill receipt on user-scope upgrade (4353241275)
- fix: fix(setup): refuse symlinked managed destinations
- …and 139 more
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
Yeachan-Heo/oh-my-codex 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 dd0eba56b209780bf3cc60b65edefa23ede6d1db — 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-110e4fee044f.