Yeachan-Heo/oh-my-codex

This system is a multi-agent orchestration platform for the Codex CLI, designed to manage complex, long-running software development workflows through specialized agents and automated coordination. It provides a structured runtime that handles session state, task allocation, and verification gates, while integrating with terminal multiplexers and external services for real-time monitoring and communication. The platform supports diverse execution modes, including autonomous planning, deep-interview workflows, and team-based task distribution, all secured by strict state invariants and native Rust-backed performance components.

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, including configuration interfaces like NormalizedTmuxHookConfig, target normalization types, and utility functions for pane state detection, injection guard evaluation, and command argument building.

src/types · high confidence

A new demo application has been added to the playground to showcase a mission for discovering latent noisy subspaces. The package includes a problem definition with a 32-dimensional objective function that maps inputs to a 4-dimensional latent space, featuring complex interactions and noise. It provides an optimizer module implementing three distinct search strategies: random search, CEM (Cross-Entropy Method) search, and a screened Bayesian GP approach that actively infers and exploits active dimensions within the latent subspace. The demo is configured via a JSON file and can be executed via a command-line interface.

_playground/bayesopt\_latent\_discovery\demo · high confidence

A new demo application has been added to the playground for optimizing noisy, high-dimensional objective functions. The demo features a 24-dimensional problem where only four specific dimensions are informative, allowing users to compare random search against a Bayesian optimization strategy using a Gaussian Process with a Matern kernel. The implementation includes configurable parameters for the search budget, acquisition function settings, and active dimension selection, accessible via a command-line interface.

_playground/bayesopt\_highdim\demo · high confidence

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

The planning module now enforces a canonical naming convention for artifacts (PRDs, test specs, and deep interviews) using timestamped slugs, ensuring consistent file identification and sorting. This change introduces a new \artifact-names.ts\ module that handles parsing, slug extraction, and matching logic, replacing previous ad-hoc patterns. Additionally, a new \markdown-structure.ts\ module provides a stateful parser that correctly identifies visible text by respecting fenced code blocks, indented code, and HTML comments, which improves the reliability of scanning planning documents for specific content.

src/planning · high confidence

The repository now includes a document-refresh enforcement system (src/document-refresh) that warns when source changes—such as updates to the Codex native hook or CLI behavior—lack corresponding updates to documentation or planning specs, with rules configurable in src/document-refresh/config.ts. Additionally, new build scripts in src/scripts (build-api.ts, build-explore-harness.ts, build-sparkshell.ts) automate compiling and staging Rust binaries, while ask-claude.sh and ask-gemini.sh provide wrapper commands for provider-specific queries.

src/scripts · high confidence

The \packages/vscode-extension\ package is now available, providing a local Chat surface within VS Code for launching and resuming direct OMX sessions, streaming session output, and managing local chat transcripts. Users can start sessions, view recent logs, and run health checks via the \omx.openChat\ command and status bar, with conversation state persisted under \.omx/vscode/conversations/\. The extension relies on the shared root \dist/vscode/index.js\ core API for session management and requires local installation via VSIX for development and dogfooding.

packages/vscode-extension · high confidence

Adds a new OpenClaw integration that allows users to configure HTTP or CLI command gateways to receive notifications. The system reads configuration from the notifications.openclaw key in .omx-config.json, supporting custom aliases for CLI and webhook commands. It maps hook events (session-start, session-end, session-idle, ask-user-question, stop) to specific gateways with customizable instruction templates. The implementation includes safe command execution with configurable timeouts (clamped between 100ms and 5 minutes), HTTPS URL validation, and shell escaping for command arguments. Reply routing context is passed through environment variables (OPENCLAW\_REPLY\_CHANNEL, OPENCLAW\_REPLY\_TARGET, OPENCLAW\_REPLY\_THREAD) to enable threaded conversations. The integration is opt-in via the OMX\_OPENCLAW environment variable and includes debug logging support.

src/openclaw · high confidence

Added a new Advisory consensus mode for Ralplan, enabling a structured, review-gated workflow for execution planning. This change introduces a comprehensive set of modules in \src/ralplan\ to manage the advisory lifecycle, including \advisory-contract.ts\ for schema definitions, \advisory-activation.ts\ for durable activation and state projection, \advisory-evidence.ts\ for secure artifact pinning and integrity verification, and \advisory-lifecycle-validation.ts\ for enforcing state transitions. The implementation ensures that advisory plans are validated against strict evidence and lifecycle constraints before execution, providing a secure and auditable path for complex planning tasks.

src/ralplan · high confidence

The SparkShell component has been rewritten in Rust to provide a native, high-performance shell for summarizing command output and capturing telemetry. This new implementation introduces a command-family registry that detects toolchains (such as Git, Node.js, Python, Rust, Go, Java/Kotlin, C/C++, .NET, Ruby, and Swift) to tailor AI-generated summaries. It includes a local API bridge that defaults to the 'gpt-6-astra' model, with automatic fallback handling for rate limits or quota errors. Security is enhanced via a redaction layer that masks authorization headers, key-value secrets, and known token prefixes (e.g., 'sk-', 'ghp\_'). The tool now supports direct command execution, shell passthrough, and tmux pane capture, with configurable line thresholds and caching for incremental monitoring.

crates/omx-sparkshell/src · high confidence

The team runtime now includes a new allocation policy engine that automatically assigns tasks to workers based on role matching, file-path and domain overlap, and current workload balance. This is complemented by a coordination protocol that analyzes task descriptions and dependencies to determine whether tasks should be handled in lightweight independent mode or require coordinated mechanisms like shared mental models and closed-loop communication. The system also introduces a current-task baseline to track active worktrees and branches, and a commit-hygiene ledger to record operational commits (checkpoints, merges, rebases) for leader review. These changes provide a structured, automated approach to distributing work and managing coordination among team workers.

src/team · high confidence

Adds a new \src/modes/base.ts\ module that provides the shared lifecycle management for all execution modes (autopilot, autoresearch, deep-interview, ralph, ultrawork, team, ultraqa, ralplan). This change establishes a common foundation for mode state handling, including validation, normalization, and start/stop logic, while also deprecating the ultrapilot, pipeline, and ecomode modes in favor of team and ultrawork.

src/modes · high confidence

The ML demo now supports model configuration via a new config.json file, allowing users to select from decision tree, random forest, extra trees, hist gradient boosting, and logistic regression models. The demo includes a model factory that instantiates the selected model with specified parameters and a training script that evaluates performance using ROC AUC and accuracy metrics on the breast cancer dataset.

_playground/ml\_kaggle\demo · high confidence

The \omx-runtime-core\ crate now provides the foundational runtime engine, introducing structured authority leasing (\AuthorityLease\) to manage exclusive ownership and lease renewal, a \DispatchLog\ to track the lifecycle of dispatch requests (pending, notified, delivered, failed) with deduplication, and a \MailboxLog\ for inter-worker message delivery tracking. These components are orchestrated by the \RuntimeEngine\, which processes commands to acquire authority, queue and mark dispatch outcomes, and manage mailbox records, while \ReplayState\ handles event deduplication and deferred leader notifications. This establishes the core state management and command-processing surface for the runtime.

crates/omx-runtime-core · high confidence

The \src/hooks/extensibility\ module now provides a complete runtime for discovering, validating, and executing external hook plugins (\.mjs\ files). This change introduces a dispatcher that spawns isolated plugin runners with configurable timeouts and resource cleanup, an event system supporting both native and derived events with confidence scoring, and a plugin SDK exposing tmux interaction, persistent state management, and read-only access to OMX session/HUD state. Plugins are enabled by default and can be opted out via the \OMX\_HOOK\_PLUGINS\ environment variable, with execution logs written to daily JSONL files for observability.

src/hooks/extensibility · high confidence

Added the leader conductor contract module and its test suite to define and enforce the Main agent's orchestration boundaries. The contract establishes the 'Golden Rule' (Main never writes implementation artifacts directly) and the 'Silver Rule' (reuse/resume specialized agents), separating orchestration metadata from delegated work. It also introduces logic to detect native subagent support status based on runtime evidence (capabilities, tool inventories, or persisted markers) and provides specific guidance blocks for failing closed when native subagents or role routing are unavailable, ensuring the system does not misinterpret incomplete tool lists as explicit support denials.

src/leader · high confidence

Added \src/native-assets/archive.ts\ and \src/native-assets/policy.ts\ to provide secure handling of native release assets. The new archive module supports inspecting and streaming members from tar.xz, tar.gz, and zip files, enforcing strict path normalization and traversal prevention. The policy module defines validation rules for release manifests, ensuring that asset metadata (such as platform, architecture, and SHA-256 integrity) matches expected targets and that archive contents are safe before extraction.

src/native-assets · high confidence

The \src/hud\ directory now contains a complete, new implementation of the HUD (Heads-Up Display) system. This includes an authority module for managing process ownership and state, a reconciliation engine to handle tmux pane lifecycle and layout, a renderer for the statusline, and utilities for tmux interaction and state reading. This replaces the previous HUD logic with a more robust, session-aware system that handles pane ownership, resize hooks, and state reconciliation.

src/hud · high confidence

This change introduces the core \src/hooks\ module for the new oh-my-codex v0.1.0 multi-agent orchestration system. It adds a comprehensive keyword detection engine (\keyword-detector.ts\, \keyword-registry.ts\) that maps user commands (like \$deep-interview\, \$ultragoal\, \$plan\) to specific skills and manages their active state. The system includes a \deep-interview-config-instruction.ts\ module to handle Socratic interview flows with ambiguity gating, and an \explore-routing.ts\ module to direct read-only repository lookups. Session management is handled by \session.ts\, which implements cross-platform process identity verification and atomic pointer locking to prevent state corruption. Additionally, \agents-overlay.ts\ dynamically injects context (codebase maps, active modes) into \AGENTS.md\, while \sunset-stub.ts\ provides a centralized registry for retired skills and their replacements.

src/hooks · high confidence

The src directory now exports the new oh-my-codex package, providing a multi-agent orchestration layer for the Codex CLI. This release adds specialized agent prompts, workflow skills, and an orchestration brain, along with a CLI tool for setup and diagnostics. It also introduces a two-layer HUD statusline for workflow tracking and integrates with VS Code via platform command launchers and environment resolution.

src · high confidence

The new omx-api crate provides a local API server and CLI tool that supports a 'real-private' backend mode, allowing users to proxy requests to a local upstream service while preserving metadata and handling authentication via environment variables. The implementation includes a daemon state management system, telemetry tracking, and comprehensive CLI tests to ensure reliability under load and correct resource cleanup.

crates/omx-api · high confidence

The \omx-runtime\ crate now provides a standalone binary that manages runtime state persistence and execution. 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 adds an \exec\ command for processing runtime commands with atomic mutation locking, and includes platform-specific helpers like \fs-rename-no-replace\ (using \SYS\_renameat2\ on Linux) and \process-identity\ for cross-platform process identification.

crates/omx-runtime/src · high confidence

Added a new \src/url-reader\ module that fetches and parses URLs to extract titles and snippets while enforcing security constraints: it blocks unsafe targets (localhost, loopback IPs, unsupported protocols), handles redirects safely with a configurable limit, and caps body reads to prevent excessive memory usage. A specific behavioral fix ensures that when a response body exactly matches the \maxBytes\ limit, the reader correctly reports the content as complete (not truncated) rather than falsely truncating it.

src/url-reader · high confidence

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 sandboxed environment using a strict allowlist of direct commands (e.g., \rg\, \grep\, \ls\) and shell wrappers, while scrubbing potentially dangerous environment variables. It implements a fallback mechanism that attempts a primary model (spark) and retries with a secondary model if the first fails, enforcing configurable timeouts, process limits, and output size caps to prevent resource exhaustion.

crates/omx-explore · high confidence

Added a new verification module that enables evidence-backed verification of task completion within the runtime. This includes logic to detect structured verification evidence in task summaries, generate specific verification instructions based on task size (small, standard, or large), determine task size from file and line changes, and provide instructions for a fix-verify loop. This supports runtime completion gates by ensuring tasks are validated against defined criteria before being marked complete.

src/verification · high confidence

Adds a new \omx sidecar\ command that reads team state from disk and renders a read-only, real-time terminal dashboard. The sidecar supports \--watch\ for continuous updates, \--tmux\ to open a split pane, and \--json\ for machine-readable snapshots. It normalizes legacy team configurations without migrating or mutating source files, sanitizes terminal output to prevent ANSI injection, and safely handles unsafe worker names and path traversal attempts.

src/sidecar · high confidence

This change adds a new goal-workflow subsystem under src/goal-workflows that persists workflow state in .omx/goals via status and ledger artifacts, enforces a strict completion gate requiring a real (non-placeholder) validation artifact, and reconciles Codex goal snapshots to preserve native statuses like 'blocked' and handle database schema errors without coercing them to 'unknown'. It also provides handoff instructions for degraded modes and includes comprehensive tests for artifact creation, validation enforcement, and snapshot reconciliation.

src/goal-workflows · high confidence

The system now defines agent roles via a structured schema in \src/agents/definitions.ts\, specifying attributes like reasoning effort, posture, model class, and tool access for roles such as 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 enforcement in \src/agents/policy.ts\ ensures that only installable native agents are processed and validates canonical targets for aliases.

src/agents · high confidence

Added new files in src/subagents to manage native subagent lifecycle and routing: tracker.ts implements a cross-process-safe JSON store for tracking subagent sessions, threads, and reopen authority (including direct-child attestation and status), while role-routing-marker.ts provides a file-based mechanism to record and query role-routing unavailability markers with expiration and session isolation.

src/subagents · high confidence

The CLI now includes \omx agents\ to manage native agent TOML files (list, add, edit, remove) in user or project scopes, \omx agents-init\ to bootstrap lightweight AGENTS.md files with managed/manual sections, and \omx adapt\ to probe, initialize, and diagnose adapter foundations for targets like OpenClaw and Hermes. These commands provide structured ways to configure agent behavior, scaffold project guidance, and verify adapter readiness.

src/cli · high confidence

The MCP layer now includes dedicated servers for code intelligence, project memory, and Hermes coordination. The code-intel server provides LSP-like diagnostics via tsc and symbol extraction for TypeScript, JavaScript, Python, Go, Rust, and other languages. The memory server introduces persistent project memory and session notepad tools for storing directives, notes, and working memory. The Hermes server exposes a coordination bridge for session management, prompt queuing, status reporting, and structured question handling. These servers are bootstrapped via a new lifecycle system that manages stdio transport, sibling deduplication, and telemetry logging.

src/mcp · high confidence

The \src/auth\ directory now contains a complete authentication subsystem that introduces auth slot storage, hot-swap lifecycle support, and automatic quota-based token rotation. Users can now manage multiple authentication profiles (slots) with strict file permissions and path validation, while the hot-swap wrapper ensures that live auth files are only updated during successful launches and are safely reverted on failure. The system also detects quota errors (such as 429s) and automatically rotates to the next available slot based on configured strategies (round-robin, priority, or manual), preserving session continuity via rollout session heuristics.

src/auth · high confidence

Added a new code-simplifier hook that automatically detects recently modified source files and delegates them to a code-simplifier agent for cleanup. This feature is opt-in and disabled by default; users must enable it in their configuration file at \~/.omx/config.json by setting codeSimplifier.enabled to true. The hook respects configuration limits for file extensions and the maximum number of files processed per trigger, and includes logic to prevent re-triggering within the same turn cycle using a marker file.

src/hooks/code-simplifier · high confidence

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 Claude settings, a TOML generator that merges first-party OMX MCP servers and feature flags while preserving user overrides, and a model resolution layer that defaults to \gpt-6-astra\ with support for \gpt-5.6\ aliases and per-agent reasoning effort. Additionally, it adds a team-mode controller to enable or disable team orchestration via environment variables or config files, a deep-interview profile resolver, and a Lore commit-guard opt-out mechanism.

src/config · high confidence

The extensibility SDK now provides a structured API for hook plugins to manage their own persistent state, interact with the terminal via tmux, and log activity. Plugins can read, write, and delete key-value pairs stored in local JSON files, send keystrokes to specific tmux panes with built-in cooldown and deduplication logic, and append structured JSON logs to a shared log file. The SDK also exposes read-only access to OMX runtime state, including session details, HUD state, and notification fallback status, allowing plugins to react to the current environment safely.

src/hooks/extensibility/sdk · high confidence

The adapter system now includes an opt-in bridge that maps OMX lifecycle and team states into Herdr semantic states (working, blocked, idle, unknown) when running inside a Herdr-managed pane. This change introduces a new 'herdr' target in the adapter registry, complete with dedicated contracts, evidence collection, and a monotonic sequence-based transport (CLI or Unix socket) for reporting state and releasing authority. The bridge is inert outside a Herdr pane and includes safeguards like message sanitization, authority reconciliation, and failure isolation to ensure best-effort, non-blocking integration.

src/adapt · high confidence

This change introduces a suite of new utility modules in src/utils to support the multi-agent orchestration and Windows stability improvements. src/utils/agents-md.ts and src/utils/agents-model-table.ts provide the logic to generate, parse, and preserve user policy blocks within AGENTS.md files, including an auto-generated model capability table. src/utils/file-durability.ts adds Windows-specific fsync handling to gracefully tolerate EPERM errors on regular files and directories, preventing crashes during session pointer updates. src/utils/worktree-tool-context.ts and src/utils/git-layout.ts establish a canonical worktree tool context, correctly resolving git common directories and worktree roots for shared or local code graph modes. Additional utilities include src/utils/package.ts for ESM-safe package root resolution, src/utils/paths.ts for canonicalizing OMX entry and launcher paths, src/utils/platform-command.ts for robust Windows command discovery and spawning, src/utils/repo-deps.ts for bootstrapping reusable node\_modules in git worktrees, src/utils/safe-json.ts for safe JSON parsing, src/utils/sleep.ts for abortable sleep functions, src/utils/toml.ts for top-level TOML string manipulation, and src/utils/version.ts for resolving display versions with git revision fallbacks.

src/utils · high confidence

The question subsystem has been restructured into a modular, state-driven system. It now introduces a deep-interview enforcement mechanism that creates binding obligations for user questions, ensuring they are satisfied before downstream execution proceeds. A new policy engine evaluates whether questions are allowed based on active workflow modes and team contexts, blocking execution in specific automated or team-owned sessions. The system also implements a robust event logging pipeline for question lifecycle tracking and a new client interface for spawning blocking question processes, providing a more reliable and auditable user interaction flow.

src/question · high confidence

The Ultragoal system now defines its core data structures and steering logic in a new \artifacts.ts\ module. This introduces explicit types for goal status (including \review\_blocked\ and \needs\_user\_decision\), steering mutation kinds (such as \add\_subgoal\ and \split\_subgoal\), and a new \UltragoalSteeringInvariantResult\ interface that enforces structural and evidence-backed constraints on goal modifications. Users will see these changes reflected in how goal plans are structured, how steering proposals are validated against invariants, and how audit trails for goal mutations are recorded.

src/ultragoal · high confidence

The monolithic team state implementation has been refactored into a set of focused modules (approvals, dispatch, dispatch-lock, events, locks, mailbox, monitor, shutdown, tasks, workers, and config) that expose a clean public API via the index. This change improves maintainability and reliability by isolating concerns such as dispatch locking, mailbox delivery, task claiming, and event monitoring, while preserving the existing team state behavior for users.

src/team/state · high confidence

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

The autoresearch feature has been refactored to replace legacy launch paths with a validator-gated skill loop and goal-based state management. This introduces a new goal workflow (src/autoresearch/goal.ts) that manages mission lifecycles, ledger entries, and completion artifacts under .omx/goals/autoresearch, ensuring explicit cleanup and snapshot reconciliation. A new contracts module (src/autoresearch/contracts.ts) defines strict parsing for sandbox.md frontmatter, requiring JSON-formatted evaluator output and supporting keep policies like 'pass\_only' or 'score\_improvement'. The runtime (src/autoresearch/runtime.ts) now integrates with canonical worktree tool contexts and excludes .omx/ runtime files from worktree clean checks. Additionally, a new validation module (src/autoresearch/skill-validation.ts) assesses completion status via either mission-validator scripts or prompt-architect artifacts, checking for architect approval and output artifacts before marking a run complete.

src/autoresearch · high confidence

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

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

The notify-hook script is restructured into a set of dedicated TypeScript modules that manage team state, tmux pane injection, and automated nudges. \active-team.ts\ now lists active teams by reading canonical state manifests, while \auto-nudge.ts\ detects agent stalls and injects continuation prompts, including logic to block auto-approval during 'deep-interview' modes. \team-dispatch.ts\ routes team notifications through a Rust runtime bridge with a JSON fallback, and \team-leader-nudge.ts\ handles leader-specific reminders and idle detection. Supporting modules like \managed-tmux.ts\ and \team-tmux-guard.ts\ provide robust tmux session resolution and pane injection safety checks, and \log.ts\ adds structured event logging to JSONL files.

src/scripts/notify-hook · high confidence

The system now uses a validated \manifest.json\ to define skills and agents, enforcing strict categories (execution, planning, shortcut, utility) and statuses (active, deprecated, alias, merged, internal) via a new schema. This catalog supports canonical aliases (e.g., \configure-discord\ merging into \configure-notifications\) and mirrors plugin skills to ensure consistency. Additionally, a visual-verdict feedback loop is introduced, allowing users to receive structured scores and actionable next steps for visual iterations, with built-in validation for verdicts and thresholds.

src/catalog · high confidence

The native hook policy in src/hooks/native has been simplified to remove hard workflow gates. PreToolUse decisions that previously blocked or denied actions are now converted into advisory messages, allowing ordinary workflows to continue; the only exceptions are specific cancel interceptions (e.g., exact-session cancellation) which remain denied to prevent double-running. Additionally, new capability warnings inform users when tmux-dependent features (team workers, HUD, question pane targeting) are unavailable in the Codex App or native outside-tmux environments, guiding them to use native alternatives or launch from a tmux shell.

src/hooks/native · high confidence

The oh-my-codex plugin now uses a native Node.js hook script (codex-native-hook.mjs) to handle lifecycle events including SessionStart, PreToolUse, PostToolUse, UserPromptSubmit, PreCompact, PostCompact, and Stop. This new implementation replaces previous shell-wrapping approaches, providing robust JSON parsing with fallbacks for malformed input, strict size limits on stdin/stdout to prevent oversized payloads, and secure routing logic that validates session metadata and transcript paths. The Stop hook specifically includes a 30-second timeout and hardened handling for oversized input, ensuring reliable cleanup and structured error responses.

plugins/oh-my-codex/hooks · high confidence

The runtime layer now routes all state mutations through a new \bridge.ts\ wrapper that executes the \omx-runtime\ binary (with SHA-256 verification and macOS arm64 native-cache resolution), while state queries read Rust-authored JSON snapshots. This is paired with a unified run-outcome contract (\run-outcome.ts\, \run-state.ts\, \run-loop.ts\, \terminal-lifecycle.ts\) that normalizes legacy outcome strings into canonical \RunOutcome\ and \TerminalLifecycleOutcome\ values, deduplicates lifecycle normalization, and preserves explicit run outcomes during state syncs. A new \process-tree.ts\ helper enforces bounded output and process limits for spawned child processes, and the runtime loop now strictly respects terminal outcomes to prevent runaway execution.

src/runtime · high confidence

The notification subsystem has been refactored into a new, unified configuration and dispatch architecture. A new \config.ts\ module now reads settings from \.omx-config.json\ and environment variables (such as \OMX\_DISCORD\_WEBHOOK\_URL\ and \OMX\_TELEGRAM\_BOT\_TOKEN\), providing backward compatibility for the legacy \stopHookCallbacks\ format. The system now supports a broader range of platforms, including native Discord bot integration, Slack, and generic webhooks, in addition to the existing Discord webhooks and Telegram. To prevent notification flooding, new \dispatch-cooldown.ts\ and \idle-cooldown.ts\ modules enforce configurable minimum intervals between dispatches, with idle notifications now using state fingerprints to suppress repeated alerts for unchanged session states. Lifecycle events (session start, stop, end) are deduplicated via \lifecycle-dedupe.ts\ to avoid duplicate broadcasts. Message content is now processed by \formatter.ts\, which cleans tmux pane output by stripping ANSI codes, UI chrome, and noise, and supports customizable message templates via a new \hook-config.ts\ system.

src/notifications · high confidence

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

The state module has been restructured to enforce a strict single-writer invariant for workflow-mode projections, routing all durable writes through a central \writeStateFile\ function in \operations.ts\ while explicitly declaring and auditing other namespace owners (such as HUD, team, and lifecycle hooks) via \namespace-owners.ts\. To prevent forged evidence from advancing Autopilot phases, a new \handoff-carrier.ts\ module validates that handoff artifacts are either absent or plain objects, throwing on malformed data like arrays or strings. Additionally, \mode-binding-lease.ts\ and its helper introduce native OS-level mutexes and file-identity checks to securely bind state ownership to process starts, while \mode-state-context.ts\ ensures Ralph pane authority is correctly captured and scoped to the active session.

src/state · high confidence

The VSCode extension now correctly spawns the underlying \omx\ process using the platform-specific command launcher. On Windows, this ensures that command shims (like \.cmd\ files) are executed via \cmd.exe\ with appropriate arguments, rather than failing to resolve the executable directly. This change also includes tests verifying that direct session arguments are built correctly, dangerous flags require approval, and child process output is redacted before logging.

src/vscode · high confidence

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 the HUD module; Added comprehensive test coverage for the notifications subsystem; Added comprehensive tests for state management invariants and operations; Added integration tests for modes/base state management and contract validation; Added runtime test coverage for bridge resolution, process management, and run outcomes; Added test coverage for OpenClaw configuration, gateway dispatching, and public API; Added test coverage for new CLI commands and internal modules; Added test coverage for team orchestration policies and protocols; Added test coverage for the question system; Added test coverage for utility modules; 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 config system internals; 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 subagent tracking and leader bootstrap logic; Added unit tests for the hook extensibility runtime and plugin infrastructure; Added verification tests for CI workflows, release artifacts, and verification logic; Expanded test coverage for hooks, skills, and runtime contracts; Expanded test coverage for native hook, release, and drift-checking logic; Wiki module test coverage and CJK query support.

This change introduces the foundational dependency manifests for the project, establishing the build environment for the core Rust workspace and the Node.js CLI. The Rust side (Cargo.toml/Cargo.lock) defines a workspace of six crates (omx-api, omx-explore-harness, omx-mux, omx-runtime-core, omx-runtime, omx-sparkshell) at version 0.21.5, relying on libraries like serde, libc, and windows-sys. The Node.js side (package.json/package-lock.json) sets up the CLI tool with dependencies on @modelcontextprotocol/sdk, zod, and tar-stream, alongside dev tools like TypeScript 7.0.2 and Biome. A separate VSCode extension manifest is also included to provide a UI for launching and monitoring sessions.

(dependencies) · high confidence

This location contains the planning and release-prep artifacts for version 0.18.13. The \ultragoal\ directory records the completed workflow for determining the release scope (patch, not minor), preparing versioned metadata across package/Cargo/plugin surfaces, and running verification/dogfood checks. The \plans/hud-state-session-reconciliation.md\ file documents the approved architectural plan to enforce session-authoritative HUD state, which is the substantive change being released, though the implementation code for that plan resides in other areas of the repository.

.gjc · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 63.

• Code Health 48
• Architecture 72
• Maturity 75
• Readiness 79
• Security 78
• Event Sourcing 100

• 300 commits — 112 feature/other, 188 fixes

• (repo) — 81 commits
• src/cli — 61 commits
• (root) — 27 commits
• src/hud — 27 commits
• src/ralplan — 21 commits
• src/hooks — 15 commits
• src/state — 15 commits
• src/team — 8 commits
• .github/workflows — 6 commits
• src/scripts — 6 commits
• docs/readme — 5 commits
• docs/qa — 4 commits
• src/autopilot — 4 commits
• plugins/oh-my-codex — 3 commits
• src/config — 3 commits
• crates/omx-runtime — 2 commits
• src/runtime — 2 commits
• docs/STATE_MODEL.md — 1 commit
• docs/agents.html — 1 commit
• docs/codex-native-hooks.md — 1 commit

• fix: Merge branch 'dev' into fix/detached-hud-failure-cleanup
• fix: Merge pull request #3537 from Yeachan-Heo/fix/issue-3536-external-team-state-root
• fix: Merge pull request #3541 from Yeachan-Heo/fix/issue-3540-detached-tmux-owner-race
• fix: Merge pull request #3546 from hiSandog/fix/url-reader-exact-limit-f9d0a0
• fix: Merge pull request #3551 from Yeachan-Heo/fix/issue-3550-madmax-root-identity
• fix: Merge pull request #3555 from Yeachan-Heo/fix/issue-3552-packed-team-skill
• fix: Merge pull request #3557 from Yeachan-Heo/fix/issue-3552-packed-smoke-hook
• fix: Merge pull request #3561 from Yeachan-Heo/fix/issue-3558-plugin-launcher-provenance
• fix: Merge pull request #3562 from berahac/fix/detached-hud-failure-cleanup
• fix: Merge pull request #3566 from Yeachan-Heo/fix/issue-3552-trusted-publish-ci
• fix: Merge pull request #3570 from Yeachan-Heo/fix/issue-3552-p1-launcher-manual-publish
• fix: Merge pull request #3571 from Yeachan-Heo/fix/issue-3552-p2-cache-namespace-release
• fix: Merge pull request #3572 from Yeachan-Heo/fix/issue-3552-p3-release-authority
• fix: Merge pull request #3579 from Yeachan-Heo/fix/issue-3577-detached-hud-polling
• fix: Merge pull request #3582 from Yeachan-Heo/fix/issue-3578-detached-cleanup-failclosed
• fix: Merge pull request #3585 from Yeachan-Heo/fix/issue-3584-hud-refresh-artifacts
• fix: Merge pull request #3588 from Yeachan-Heo/fix/3587-hud-pane-ownership
• fix: Merge pull request #3590 from Yeachan-Heo/fix/3589-empty-hooks-state
• fix: Merge pull request #3592 from XCRobert/fix/ralph-native-app-deadlock
• fix: Merge pull request #3595 from NagyVikt/agent/codex/fix-tmux-set-hook-argv-separator-2026-08-30-17-40
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

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.