Skip to content
CAI
Software that uses CAICheck a score

Yeachan-Heo/oh-my-claudecode

54.7

Adequate · 26 October 2026

488.6k

lines of production code

TypeScript

with JavaScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Oh-My-ClaudeCode is a multi-agent orchestration framework that extends Claude Code by managing a fleet of specialized agents (e.g., architect, executor, reviewer) and coordinating their work through a deterministic graph-based runtime. It provides intelligent model routing to assign tasks to appropriate AI tiers, enforces strict security and safety via sandboxed execution and approval gates, and supports autonomous workflows like parallel task decomposition and self-improvement loops. The system also includes comprehensive tooling for benchmarking, workspace checkpointing, and cross-platform integration with various Git hosting providers.

Features

Add OMC\_DISABLE\_TOOLS environment variable to filter MCP tools

Users can now selectively disable groups of MCP tools (such as LSP, Python REPL, or Skills) by setting the OMC\_DISABLE\_TOOLS environment variable. The system parses a comma-separated list of group names (e.g., 'lsp,python-repl') and automatically excludes those tools from the available toolset at startup.

dist/mcp · high confidence

Add SWE-bench benchmark runner for Claude Code evaluation

A new Python script, \benchmark/run\_benchmark.py\, has been added to evaluate Claude Code against the SWE-bench Verified dataset. This tool supports running benchmarks in both 'vanilla' and 'OMC' (Oh My Claude Code) modes, allowing users to compare performance. It includes features for parallel execution, checkpointing to resume interrupted runs, and detailed logging of statistics such as success rates and token usage.

python · high confidence

Add multi-provider git hosting abstraction for GitHub, GitLab, Bitbucket, Azure DevOps, and Gitea

Users can now interact with pull requests and issues across five major git hosting platforms using a unified interface. The new provider layer in src/providers auto-detects the hosting service from the git remote URL and delegates to the appropriate adapter: GitHub (via gh CLI), GitLab (via glab CLI), Bitbucket (via REST API with token or basic auth), Azure DevOps (via az CLI), and Gitea/Forgejo (via tea CLI or REST API with optional auth token). Self-hosted GitLab and Gitea instances are detected by hostname patterns, and Gitea URLs are validated against SSRF risks. The implementation includes a central registry and URL parser in src/providers/index.ts, shared type definitions in src/providers/types.ts, and individual provider files (github.ts, gitlab.ts, bitbucket.ts, azure-devops.ts, gitea.ts) that handle PR/issue viewing, authentication checks, and CLI requirements.

src/providers · high confidence

Add multi-provider support for Azure DevOps, Bitbucket, Gitea, and GitLab

The Project Session Manager now supports Azure DevOps, Bitbucket, Gitea, and GitLab in addition to the existing GitHub and Jira integrations. New provider scripts in \skills/project-session-manager/lib/providers\ implement detection, pull request/issue fetching, and status checking for these platforms, allowing users to manage sessions across a wider range of hosting services.

skills/project-session-manager/lib/providers · high confidence

Add oh-my-claudecode CLI entry point

A new executable script, bin/oh-my-claudecode.js, has been added to the project. This script serves as a CLI entry point that delegates execution to the existing bridge/cli.cjs module, enabling users to run the tool via this specific binary path.

bin · high confidence

Add vendor reference MCP server for company context

Added a minimal, runnable reference implementation of the company-context MCP contract in the examples/vendor-mcp-server directory. This server exposes a single tool, get\_company\_context, which accepts a natural-language query and returns informational markdown covering security guidelines, review checklists, and domain glossary terms. It serves as a portable example for vendors to integrate with the company-context interface documented in the project.

examples/vendor-mcp-server · high confidence

Added Claude goal snapshot parsing and reconciliation logic

The goal-workflows module now includes a new \claude-goal-snapshot\ component that parses JSON payloads from the Claude agent's \/goal\ command, normalizing various status and objective field names (such as \condition\ for \objective\ or \cleared\ for \cancelled\). It provides a reconciliation function to verify that the agent's reported state matches the expected ultragoal plan, flagging mismatches in objectives or statuses as errors or warnings. This logic is supported by a comprehensive test suite covering input parsing, status normalization, and error handling for malformed or missing snapshots.

dist/goal-workflows, src/goal-workflows · high confidence

Agent architecture restructured with modular definitions and tiered model routing

The agent system has been reorganized from a monolithic registry into a modular structure where each agent (e.g., architect, executor, qa-tester) is defined in its own file with dedicated metadata for cost, category, and delegation triggers. This change introduces a 3-tier model routing system (LOW/MEDIUM/HIGH) that automatically assigns models like Haiku, Sonnet, or Opus based on task complexity, allowing users to benefit from optimized cost-performance trade-offs. Additionally, the registry now includes new specialized agents such as tracer for causal analysis and verifier for completion evidence, while consolidating previous overlapping roles into a streamlined set of 18 base agents.

src/agents · high confidence

Alias retirement verifier and closure inventory

The \src/alias-retirement\ module now provides the executable verifier and closure inventory for retiring deprecated skill aliases. It enforces a strict retirement policy requiring a major-version boundary, or alternatively, a combination of temporal thresholds (2 minor releases and 90 days), a 95% canonical usage share over two consecutive releases, and zero critical integrations. The verifier produces machine-readable receipts that determine whether an alias is eligible for removal, while the closure inventory tracks generated artifacts to ensure they are only deleted after their owning alias is proven eligible, preventing premature cleanup.

src/alias-retirement · high confidence

Autoresearch introduces structured mission contracts and setup handoffs

The autoresearch feature now enforces strict contracts for mission definitions and setup data. New \contracts.ts\ and \setup-contract.ts\ files define how sandbox evaluations are parsed (requiring YAML frontmatter with specific evaluator commands and JSON output) and how setup handoffs are validated (including confidence thresholds and keep policies). This ensures that autoresearch missions are consistently structured and that the system can reliably parse and execute evaluation scripts defined in mission sandboxes.

src/autoresearch · high confidence

Background agent concurrency and task management

The background-agent feature now includes a ConcurrencyManager that enforces configurable concurrency limits for background tasks, supporting per-model, per-provider, and default limits with automatic queueing when capacity is reached. The BackgroundManager persists task state to disk, prunes stale tasks based on configurable timeouts, and detects inactive sessions to mark them as errored, ensuring reliable background task lifecycle management.

dist/features/background-agent · high confidence

Dynamic orchestrator prompt generation for multi-agent coordination

The system now dynamically constructs the orchestrator's instruction set based on available agent configurations. This new module generates specific prompt sections including an identity header, an agent registry that distinguishes between primary and tiered variants (HIGH/MEDIUM/LOW), a trigger table for agent selection, tool selection guidance, a delegation matrix, and core orchestration principles. This allows the orchestrator to automatically adapt its behavior and delegation strategies to the currently defined set of subagents.

src/agents/prompt-sections · high confidence

Dynamic orchestrator prompt generation for multi-agent systems

The \dist/agents/prompt-sections\ module now provides a set of functions to dynamically build sections of the orchestrator prompt based on agent metadata. This includes generating the header, an agent registry (grouped by tier), trigger tables, tool selection guidance, a delegation matrix, orchestration principles, workflow instructions, critical rules, and a completion checklist. Adding a new agent automatically updates the orchestrator's context, ensuring consistent behavior and guidance for the multi-agent system.

dist/agents/prompt-sections · high confidence

Factory chain intake, map-driven execution, and audit visibility

The factory now accepts GitHub events via a listener daemon that verifies HMAC signatures, enforces a repository whitelist, and routes tracker issues (labeled 'intake') to the intent stage and CI check-suite failures to the diagnose stage. Map-driven runs are supported through a frontier enumerator that classifies child tickets as auto-executable or human-gated based on labels and blocking relations, allowing the system to claim criteria-carrying tickets, draft acceptance criteria for others, and stop at human gates. A read-only chain audit view summarizes active ledgers, intent decisions, and stalled links, while map execution writes a session PRD, launches the chain, and closes verified source tickets with evidence.

src/factory · high confidence

Graph Core descriptor validation and deterministic scheduler implementation

The \dist/graph\ module now includes the compiled JavaScript and TypeScript declaration files for the Graph Core surface. This adds strict descriptor sealing and structure-before-hash validation (via \descriptor.js\), ensuring that graph definitions are parsed, validated, and hashed with deterministic canonical JSON serialization before being passed to the scheduler. It also introduces the pure deterministic scheduler (\scheduler.js\), which manages graph execution state through hash-fenced projections, replay-fenced mutations, and specific transitions for node results, human approvals, and join resolution, all bound to the sealed descriptor hash to prevent tampering or drift.

dist/graph · high confidence

Graph runtime v2 introduces secure execution with approval gates and containment

The graph runtime has been upgraded to version 2, introducing a hardened execution model that enforces strict directory containment to prevent path traversal and symlink attacks across Linux and macOS. This release adds human approval gates for both interactive (stdin) and remote (file-backed) workflows, ensuring fail-closed behavior on unrecognized input or timeouts. It also implements an epoch-based ownership fence to prevent concurrent writer races, an append-only journal with cryptographic fingerprinting for integrity verification, and a crash-recovery runner that replays committed records to restore state. Additionally, a new ASCII progress reporter provides real-time status updates for runs and node executions.

src/graph/runtime · high confidence

Graph runtime v2 introduces secure execution, ownership fencing, and human approval gates

The graph runtime has been updated to version 2, introducing several new core capabilities and security controls. A new human approval gate allows interactive y/n prompts for critical actions, failing closed on unrecognized input or stream closure. Execution is now bounded by a contained file-system API that restricts operations to specific directory file descriptors, preventing path traversal and ensuring safe file access on Linux and macOS. An epoch-based ownership fence manages run-level concurrency using atomic file locks and tombstones to prevent race conditions. Additionally, an append-only journal with SHA-256 fingerprinting ensures data integrity, while new executors for commands and agents provide structured execution with strict environment allowlisting and read-only tool constraints for AI agents.

dist/graph/runtime · high confidence

HUD introduces agent classification and background task management

The HUD now classifies incoming agent messages and spawns (subagent, teammate, peer-session) to provide accurate ownership metadata while discarding payload bytes for security. It also manages background tasks by tracking their lifecycle, remapping IDs, and cleaning up stale or orphaned tasks that persist from previous sessions. Additionally, the HUD status line now uses color-coded indicators for model tiers (Opus, Sonnet, Haiku) and context window usage to improve visual clarity.

dist/hud · high confidence

HUD now displays API key source and agent activity details

The HUD now includes new elements to provide greater transparency into the session environment and agent activity. The API Key Source element detects and displays whether the active ANTHROPIC\_API\_KEY is configured at the project level, global level, or via an environment variable, without exposing the key itself. Additionally, the Agents element has been expanded to support multiple display formats, including single-character type codes color-coded by model tier (Opus vs Sonnet/Haiku), duration indicators, and detailed descriptions of what each agent is doing. The Autopilot element now renders workflow-specific progress, including stage names and iteration counts, while the Call Counts element provides real-time metrics on tool calls, agent invocations, and skill usages with emoji or ASCII fallbacks for cross-platform compatibility.

dist/hud/elements · high confidence

Initial repository scaffolding for oh-my-claudecode v5.5.0

The repository has been initialized with the core configuration and documentation files for the v5.5.0 release. This includes \.gitattributes\ to enforce line-ending consistency across platforms, \.mcp.json\ to register the OMC bridge MCP server, and \AGENTS.md\ which defines the multi-agent orchestration protocol, delegation rules, and agent catalog. The release is further documented via \CHANGELOG.md\, \CLAUDE.md\ for session guidance, \CONTEXT.md\ for glossary terms, and \CONTRIBUTING.md\ for developer setup instructions.

(repo-wide) · high confidence

Installer adds robust CLAUDE.md analysis and transaction engine

The installer now includes a new analysis module that parses CLAUDE.md files to detect OMC markers and legacy guide patterns while preserving exact byte content and line endings, alongside a transaction engine that manages safe, atomic updates to these files with automatic backups, strict path validation, and rollback capabilities to prevent data loss during configuration changes.

dist/installer · high confidence

Intelligent model routing based on task complexity

The system now automatically selects the appropriate model tier (Haiku, Sonnet, or Opus) for sub-agent tasks by analyzing prompt complexity. It extracts lexical, structural, and context signals—such as keyword presence, subtask count, and cross-file dependencies—to score tasks and assign them to the most cost-effective tier. The router also supports agent-specific overrides, explicit model selection, and automatic escalation to higher tiers if previous attempts fail.

src/features/model-routing · high confidence

Intelligent model routing for sub-agent tasks

The system now automatically routes sub-agent tasks to the most appropriate model tier (Haiku, Sonnet, or Opus) based on task complexity. This feature analyzes lexical, structural, and contextual signals—such as keyword usage, estimated subtasks, and impact scope—to assign a complexity score and select the optimal model. It includes a rules engine for specific agent behaviors (e.g., architects for debugging, planners for strategic tasks) and a scoring system that weighs factors like word count, risk keywords, and reversibility. Users benefit from more efficient resource usage and better performance on complex tasks, as the system proactively selects the right model tier rather than using a default.

dist/features/model-routing · high confidence

Intelligent model routing with tier-specific prompt adaptations

The system now automatically adapts prompts based on the selected model tier (Opus, Sonnet, or Haiku) to optimize performance. High-tier (Opus) prompts enforce deep reasoning, edge-case analysis, and strategic planning. Medium-tier (Sonnet) prompts focus on efficient, structured task execution. Low-tier (Haiku) prompts strip verbosity to maximize speed and conciseness. This change introduces the prompt adaptation logic and templates in the model-routing feature, ensuring users get behavior tailored to the model's capabilities without manual prompt engineering.

src/features/model-routing/prompts · high confidence

Introduce Graph Core contract with deterministic scheduler and descriptor validation

This change adds the foundational Graph Core module in \src/graph\, establishing the data contract, validation, and execution logic for graph-based workflows. It introduces strict Zod-based schema validation for graph descriptors, nodes, and edges, alongside a deterministic scheduler that manages activation, branching, and joining. The module enforces descriptor integrity through SHA-256 hashing and canonical JSON serialization, ensuring that graph structures are sealed and verified before execution. This provides the core infrastructure for defining, validating, and running complex, multi-node workflows with support for agent, command, human-approval, and join node types.

src/graph · high confidence

Introduce Notepad Wisdom module for capturing plan learnings and decisions

A new 'Notepad Wisdom' feature has been added to automatically capture and persist agent learnings, decisions, issues, and problems. The module parses agent completion responses using regex patterns to extract content from \<wisdom\>, \<learning\>, \<decision\>, \<issue\>, and \<problem\> tags, and writes timestamped entries to markdown files within a plan-scoped directory (.omc/notepads/{plan-name}/). This provides a structured way to track plan progress and insights.

src/features/notepad-wisdom · high confidence

Introduce Project Session Manager (PSM) skill for isolated worktree-based development

Adds the Project Session Manager skill, enabling users to create isolated development environments using git worktrees and optional tmux sessions for PR reviews, issue fixes, and feature development. The skill supports multiple issue-tracking providers (GitHub and Jira), allows configuration of project aliases via \\~/.psm/projects.json\, and includes commands for managing session lifecycles (list, attach, kill, cleanup). It also integrates with the \omc teleport\ command for worktree creation and ensures session names are tmux-safe to prevent silent rewriting issues.

skills/project-session-manager · high confidence

Introduce Project Session Manager (PSM) skill for multi-provider issue and PR workflows

The new Project Session Manager skill adds a suite of Bash utilities in skills/project-session-manager/lib to manage project aliases, Git worktrees, and tmux-based AI sessions. It supports GitHub and Jira providers, allowing users to reference issues and pull requests via aliases (e.g., omc\#123) or direct URLs. The skill handles creating isolated worktrees for PR reviews and issue fixes, managing session lifecycles with file locking, and launching Claude Code in tmux with safe session naming and automatic context injection.

skills/project-session-manager/lib · high confidence

Introduce Ralphthon autonomous hackathon lifecycle mode

Ralphthon adds an autonomous workflow that guides a project from a deep-interview intake through PRD generation, task execution, and an automatic hardening phase, terminating only after a configured number of consecutive clean waves. The mode introduces a new PRD schema with support for hardening tasks, a brownfield planning context for existing codebases, and an orchestrator that manages tmux-based execution, idle detection, and phase transitions.

src/ralphthon · high confidence

Introduce agent and command node executors for graph runtime

Added new executors for the graph runtime: the AgentNodeExecutor runs nodes via the @anthropic-ai/claude-agent SDK with read-only tool access, timeout handling, and idempotency support, while the CommandNodeExecutor spawns shell commands with environment allowlisting, output tailing, and cross-platform process-tree termination (including hiding spawned windows on Windows).

src/graph/runtime/executors · high confidence

Introduce boulder-state module for work plan tracking

Added a new boulder-state feature module that manages the active work plan state for the OMC orchestrator. This includes constants for state directories and file paths, TypeScript types for state and plan progress, and storage operations to read, write, and clear the boulder state file (boulder.json). The module also provides utilities to find planner plans, calculate checkbox progress from markdown files, and track session IDs associated with active plans.

src/features/boulder-state · high confidence

Introduce bundled builtin skills feature with runtime provider detection

The application now includes a new \builtin-skills\ feature that loads and manages bundled skills (such as \deep-interview\, \ralplan\, and \ralph\) from the \skills\ directory. This feature introduces runtime detection for available AI providers (Claude, Codex, Gemini, Grok, and Antigravity) to dynamically inject provider-specific execution guidance into skill templates. It also enforces a denylist of Claude Code native commands (e.g., \/review\, \/plan\, \/compact\) to prevent skill short names from overriding built-in functionality, and resolves the \deep-interview\ ambiguity threshold from user settings files at runtime rather than using hardcoded values.

src/features/builtin-skills · high confidence

Introduce deterministic prompt SSOT composer and projection system

A new single-source-of-truth (SSOT) system for agent prompts has been added to the \dist/agents/prompt-ssot\ module. This system replaces legacy, manually maintained prompt files (such as \CLAUDE.md\ and \agents/\*.md\) with a deterministic composer that generates projections from a central manifest and a set of canonical sections. The composer ensures byte-identical output for the same inputs by sorting sections by kind rank and ID, normalizing whitespace, and computing SHA-256 digests. It supports role-based projections (planner, executor, reviewer, verifier) and allows provider/model-specific overlays (e.g., Codex high-tier vs. Gemini low-tier) to inject data-select deltas without duplicating normative policy text. The module includes a manifest defining required sections and projection catalogs, a digest module for integrity verification, and a metrics module for measuring token duplication and projection drift.

dist/agents/prompt-ssot · high confidence

Introduce native contained filesystem for directory-relative operations

Added a new native C module (contained-fs.c) that exposes Node-API functions for filesystem operations relative to a directory file descriptor (openat, mkdirat, fstatat). This implementation avoids libuv linkage to keep the ABI stable and provides directory-relative operations specifically for the graph store, addressing filesystem path handling on Darwin.

native · high confidence

Introduce plan-scoped notepad wisdom and rate-limit wait daemon

This release adds a new Notepad Wisdom module that automatically extracts structured learnings, decisions, issues, and problems from agent completion responses and saves them as timestamped markdown files in a plan-specific directory. It also introduces a Rate Limit Wait daemon that monitors API rate limits and automatically resumes blocked tmux panes when limits reset, while preventing stale notifications by tracking per-pane scrollback history.

dist/features/rate-limit-wait · high confidence

Introduce prompt SSOT composer and projection digests

Added a new single-source-of-truth (SSOT) system for agent prompts in \src/agents/prompt-ssot\. This introduces a manifest-driven architecture where normative prompt clauses are authored exactly once in \sections.ts\ and composed into deterministic, versioned projections (e.g., \coordinator\, \role-planner\) via \compose.ts\. The system supports provider and model-tier overlays (e.g., \provider/codex\) as data selects rather than copied prose, ensuring policy text remains consistent across variants. It includes a \digest.ts\ module for SHA-256 hashing of normalized prompt bodies to detect drift, and a \metrics.ts\ module for analyzing token duplication and projection drift. The \manifest.ts\ file defines the projection catalog, required sections, and rollback history, while \types.ts\ establishes the schema for sections, overlays, and composed outputs. Comprehensive tests in \prompt-ssot.test.ts\ verify deterministic composition, manifest integrity, overlay behavior, and normalization invariance.

src/agents/prompt-ssot · high confidence

Introduce rate-limit auto-resume daemon and tmux pane detection

A new background daemon monitors usage API rate limits and automatically resumes blocked Claude Code sessions in tmux panes when limits reset. The feature includes a daemon process with secure file permissions, a rate-limit monitor that checks 5-hour, weekly, and monthly usage quotas, and a tmux detector that identifies blocked panes using specific UI patterns while filtering out stale history and false positives from git output or saved transcripts.

src/features/rate-limit-wait · high confidence

Introduce self-improve autonomous code improvement skill

Adds a new 'self-improve' skill that runs an autonomous evolutionary loop to improve code in a target repository. The skill orchestrates a multi-agent workflow (research, planning, architecture/critic review, execution, and tournament selection) to iteratively propose and merge changes based on benchmark scores. It introduces topic-scoped artifact storage (under \.omc/self-improve/topics/{slug}/\) with session isolation for concurrent runs, while preserving legacy flat layouts for backward compatibility. Users configure improvement goals, benchmarks, and guardrail harness rules (H001–H003) via interactive setup, after which the loop runs autonomously until a stop condition is met. Supporting scripts handle path resolution, progress visualization, and sealed-file enforcement to prevent self-modification of evaluation code.

skills/self-improve · high confidence

Introduce task decomposition engine for parallelizable subtask generation

Added a new task decomposition feature that analyzes user tasks to identify parallelizable components and generates structured subtasks with non-overlapping file ownership. This engine determines execution order, assigns file patterns to specific subtasks to prevent conflicts, and provides detailed prompts and acceptance criteria for each component, enabling more efficient parallel processing of complex development tasks.

src/features/task-decomposer · high confidence

Introduce unified delegation router with configurable role-based routing

A new delegation routing system has been added to determine which provider and tool to use for a given agent role. The router supports explicit tool invocations, configurable role-based routing (currently disabled by default), and a default heuristic that maps roles to Claude subagents. It also handles deprecated MCP providers (Codex/Gemini) by warning users and falling back to Claude Task, and normalizes legacy role aliases to canonical names.

src/features/delegation-routing · high confidence

Introduce unified state manager with XDG support and TOCTOU protection

A new state management module has been added to standardize how state files are stored and accessed. It introduces a dual-location model: local state is now stored in \.omc/state/\ relative to the project root, while global state uses XDG-compliant paths with a fallback to the legacy \\~/.omc/state\ directory for backward compatibility. The implementation includes a read cache with a 5-second TTL and a 200-entry size limit to improve performance. Crucially, the read operation now captures the file modification time before reading the content to prevent Time-of-Check to Time-of-Use (TOCTOU) race conditions that could lead to caching stale or corrupted data. Legacy state paths for various features (e.g., boulder, autopilot, ralph) are preserved and checked during reads to ensure smooth migration.

src/features/state-manager · high confidence

Lookout pre-flight danger scan for autonomous runs

The Lookout feature is introduced as a pre-flight danger scan for autonomous runs, analyzing task briefing text and workspace state to emit a machine-readable report of findings. It detects high-risk operations such as force pushes, protected branch pushes, destructive database commands (DROP, DELETE, TRUNCATE), and tracked secret files, while correctly handling negations (e.g., 'do not push') and various shell quoting/substitution edge cases to minimize false positives. The scan is advisory-only, providing actionable advice like creating checkpoints or using approval gates, and fails closed with specific exit codes for broken or nonexistent repositories.

src/features/lookout · high confidence

MCP tool surface hardening and observability

The MCP server surface now includes a configurable tool-disabling mechanism via the OMC\_DISABLE\_TOOLS environment variable, allowing users to filter entire tool families (such as LSP, AST, or Python REPL) at startup. To prevent prompt injection and path traversal when passing context files to external agents, the server validates file paths against the working directory and rejects control characters. Background job management tools now support structured output path policies and persistence, while a mandatory subagent header prevents recursive agent spawning. Additionally, the standalone server exposes a comprehensive audit trail for prompts and responses, and includes robust shutdown and team-cleanup handlers to prevent orphaned processes.

src/mcp · high confidence

Major API surface expansion and rebranding of the core library

The \src\ module has been rebranded from 'Oh-My-Claude-Sisyphus' to 'Oh-My-ClaudeCode' and significantly expanded its public API. The main entry point (\src/index.ts\) now exports a comprehensive suite of new capabilities, including a background task management system (\createBackgroundTaskManager\), an auto-update system (with version checking and update functions), and a 'Lookout' pre-flight danger scanning API. Additionally, it exposes team worker recovery utilities (\recoverDeadWorkerV2\), an MCP tools server (\omcToolsServer\), and a broader set of agent definitions and features (such as boulder state management and context injection). This reflects a shift from a simple orchestration library to a full-featured plugin runtime with extensive internal tooling and state management exposed to consumers.

src · high confidence

New AST-aware code search and incremental deepinit manifest tools

The dist/tools directory now includes two new capabilities. First, ast-tools provides AST-aware code search and transformation using ast-grep, supporting over 25 programming languages with pattern matching and code replacement while preserving structure; it includes path restriction validation to ensure operations stay within the project root boundary when OMC\_RESTRICT\_TOOL\_PATHS is enabled. Second, deepinit-manifest introduces a deterministic manifest system for incremental /deepinit operations, tracking directory file lists to regenerate AGENTS.md only for directories whose structure has actually changed, with actions to diff, save, and check manifest validity. Both tool sets are registered in the tool index and available via the MCP server.

dist/tools · high confidence

New CLI commands for alias retirement verification and capability locking

The CLI now includes two new diagnostic commands: \omc alias-retirement\ and \omc capabilities\. The alias retirement command acts as a read-only verifier that checks aliases against a strict retirement contract (requiring 2 minor releases, 90 days, 95% canonical share, and zero critical integrations) and generates machine-readable receipts and closure reports without deleting any files. The capabilities command introduces a deterministic local runner that collects the current tool, agent, and skill surface, runs a suite of default fixtures (such as tool selection and argument validity), and generates a lockfile (\omc-capabilities.lock.json\) to ensure the runtime surface remains stable across versions. Also in this area: Engine v5.7.16 release with improved trust detection and git merge handling; Improved token count formatting and PR/MR URL parsing robustness.

dist/cli/commands, dist/cli/utils · high confidence

New CLI commands for multi-provider queries, guided autoresearch, graph execution, and workspace checkpoints

The CLI now exposes several new subcommands to expand autonomous and interactive capabilities. The \omc ask\ command allows querying multiple AI providers (Claude, Codex, Gemini, Antigravity, Grok, and Cursor) with support for role-based agent prompts. A guided autoresearch setup flow has been introduced via \autoresearch-guided.ts\ and \autoresearch-intake.ts\, enabling users to define research missions and evaluators through an interactive interview process, while the legacy \omc autoresearch\ command is now deprecated. The \omc graph\ command enables the execution of sealed graph descriptors with remote approval gates and safety checks. Additionally, the \omc checkpoint\ command provides workspace snapshot and rollback functionality for autonomous runs, and the \omc interop\ command facilitates split-pane tmux sessions for interacting with both Claude Code and Codex CLI simultaneously.

src/cli · high confidence

New CLI utility functions for colored output and token count formatting

A new formatting utility module has been added to the CLI, providing a set of ANSI color helpers (red, green, yellow, blue, magenta, cyan, gray, bold) and a function to format token counts into human-readable strings (e.g., '1.5k', '2.00M'). This enables consistent styling and clearer display of token usage metrics in command-line output. Also in this area: Fix teleport URL parsing and token count formatting.

src/cli/utils · high confidence

New Delegation Categories system for semantic task routing

A new category-based delegation system has been added to the \src/features/delegation-categories\ module, layering semantic grouping on top of the existing ComplexityTier model routing. This feature allows tasks to be automatically detected and routed to specific agent configurations based on their nature (e.g., 'visual-engineering', 'ultrabrain', 'artistry', 'quick', 'writing'). Each category defines specific model tier, temperature, and thinking budget settings, and can append category-specific guidance to prompts. The system includes auto-detection via keyword matching, explicit category/tier overrides, and integration hooks for orchestrators to select appropriate agents (like designers or architects) based on the detected category.

src/features/delegation-categories · high confidence

New Notepad Wisdom module for capturing plan learnings and decisions

A new plan-scoped notepad system has been added to capture learnings, decisions, issues, and problems. The module creates markdown files in \.omc/notepads/{plan-name}/\ and provides functions to initialize the directory, add timestamped entries, and read or summarize wisdom by category. It also includes a parser that extracts wisdom from agent completion responses using structured tags like \\<learning\>\, \\<decision\>\, and \\<wisdom category="..."\>\.

dist/features/notepad-wisdom · high confidence

New OMC orchestration session API for direct SDK integration

The \dist\ directory now includes the compiled entry point (\index.js\ and \index.d.ts\) for the Oh-My-ClaudeCode library, exposing a new \createOmcSession\ function. This API allows developers to programmatically configure and run multi-agent orchestration sessions using the \@anthropic-ai/claude-agent-sdk\ without relying on the interactive Claude Code plugin UI. The session object provides query options (including system prompts, agent definitions, MCP servers, and allowed tools), a state manager, and helpers for processing prompts with magic keywords and managing background tasks.

dist · high confidence

New SWE-bench benchmark suite for comparing vanilla and OMC-enhanced Claude Code

Added a complete benchmarking infrastructure in the \benchmark/\ directory to evaluate and compare standard Claude Code against the oh-my-claudecode (OMC) orchestration layer using the SWE-bench Verified dataset. This includes a Dockerized evaluation environment (\Dockerfile\, \docker-compose.yml\) that supports both vanilla and OMC modes, along with shell scripts (\setup.sh\, \quick\_test.sh\, \run\_vanilla.sh\, \run\_omc.sh\, \run\_full\_comparison.sh\) for executing runs. The suite provides Python tools (\run\_benchmark.py\, \evaluate.py\, \compare\_results.py\, \analyze\_failures.py\) to generate predictions, run official SWE-bench evaluations, and produce detailed comparison reports on pass rates, token usage, and failure patterns. Configuration is managed via \.env.example\, and results are stored in structured directories for vanilla and OMC predictions, logs, and analysis.

benchmark · high confidence

New artifact handoff system and expanded routing configuration

The shared module now includes a new artifact-handoff mechanism that allows components to pass data either inline (for small payloads under 2048 bytes) or via file descriptors (for larger content), complete with content hashing and retention policies. Additionally, the shared type definitions have been expanded to support a \forceInherit\ routing option, which allows agents to bypass model routing and inherit the parent model setting, alongside a broader set of supported team agent types including 'antigravity' and 'cursor'.

dist/shared · high confidence

New atomic file writing and cross-process locking utilities

The distribution now includes new \atomic-write\ and \file-lock\ modules. The atomic-write module provides durable, crash-safe file writes using a temp-file-and-rename pattern with optional fsync and hooks, while the file-lock module implements cross-process advisory locking using exclusive file creation (O\_CREAT\|O\_EXCL) with PID-based stale lock detection and retry/timeout support. These utilities are self-contained and have no external dependencies, ensuring reliable state management and coordination in concurrent environments.

dist/lib · high confidence

New auto-update and background task management capabilities

The distribution now includes the \auto-update\ and \background-tasks\ feature modules. The auto-update system provides version checking against GitHub releases, automatic download and installation, and configurable notification profiles for Discord, Telegram, Slack, and file logging, with an opt-in prompt for upgrades at session start. The background task module introduces heuristics to decide when commands should run in the background versus foreground, manages task lifecycles, and enforces concurrency limits to improve agent efficiency.

dist/features · high confidence

New background agent feature with concurrency control and task persistence

The background-agent module has been introduced to manage long-running, autonomous tasks (Autopilot) outside the main interaction loop. This feature allows users to launch background tasks that persist across sessions via disk storage, track their progress, and resume them later. It includes a concurrency manager that enforces configurable limits on parallel execution per model or provider, preventing resource exhaustion, and automatically prunes stale or timed-out tasks.

src/features/background-agent · high confidence

New bridge runtime components and protocol handlers

The bridge directory now includes several new runtime files that establish the core communication and execution infrastructure. The \claude-md-coordinator.cjs\ file introduces a coordinator with a handshake mechanism and handles legacy \CLAUDE.md\ corpus migrations. The \gyoshu\_bridge.py\ file adds a Python bridge that executes code via a JSON-RPC 2.0 protocol over Unix sockets (or TCP on Windows), featuring structured output parsing for scientific markers. Additionally, \mcp-server.cjs\, \team-bridge.cjs\, and \team-mcp.cjs\ provide the Node.js runtime for the Model Context Protocol (MCP) and team orchestration, while \run-mcp-server.sh\ serves as a wrapper to ensure global npm modules are resolvable for native dependencies.

bridge · high confidence

New build and verification scripts for plugin distribution and CI integrity

The scripts directory now includes a suite of new build and verification tools to support the plugin distribution model and CI release workflows. Build scripts (build-bridge-entry, build-cli, build-mcp-server, build-team-server, build-runtime-cli, build-skill-bridge) bundle TypeScript sources into standalone CJS/ESM bundles in the bridge/ and dist/ directories, handling native module externalization and import.meta.url polyfills. A new build-generated-artifact-authorization script automates the creation of GitHub artifact authorization records for release PRs by diffing dist/ and bridge/ paths. Additionally, build-prompt-ssot.ts generates and verifies deterministic prompt projections, and audit-multirepo-e2e.mjs provides an end-to-end test fixture for multi-repo workspace functionality.

scripts · high confidence

New context injection and tiered prompt adaptation features

This update introduces a context injection system that allows multiple sources to register context entries which are then merged and injected into user prompts with priority ordering and deduplication. It also adds tiered prompt adaptations for Opus, Sonnet, and Haiku models, providing model-specific prompt templates and strategies to optimize instructions based on the model's capability tier.

dist/features/context-injector, dist/features/model-routing/prompts · high confidence

New context injection system for merging and injecting session context

A new context-injector module has been added to manage and inject context from multiple sources into user prompts. This system allows different components (such as project memory, rules, or directory agents) to register context entries with specific priorities and sources. The collector merges these entries, sorts them by priority and timestamp, and injects the combined content into messages using configurable strategies (prepend, append, or wrap), ensuring that critical context is prioritized and deduplicated within a session.

src/features/context-injector · high confidence

New diagnostic, session, and workflow CLI commands

The CLI now includes several new commands to improve diagnostics, session management, and workflow automation. The \omc doctor conflicts\ command scans for plugin coexistence issues, legacy CLAUDE.md markers, and Windows-unsafe hook configurations. The \omc doctor team-routing\ command probes the PATH for configured team role-routing providers (Claude, Codex, Gemini, Grok, Cursor, Antigravity) and reports availability. Session management is enhanced with \omc session-friction-report\ to analyze local session artifacts for friction signals and \omc session-search\ to search session history. Workflow capabilities are expanded with \omc alias-retirement\ to verify alias retirement eligibility, \omc capabilities\ to generate deterministic capability lockfiles, \omc ralphthon\ for an autonomous hackathon lifecycle mode, and \omc ultragoal\ for durable multi-goal workflows with Claude Code integration.

src/cli/commands · high confidence

New feature modules for agent addressability, background tasks, and delegation categories

This release introduces several new feature modules in src/features. The agent-addressability module (\#3665) makes unnamed background agents discoverable and addressable by description, with stable short IDs for listings and notifications. A new background-tasks module provides heuristics to decide when commands should run in the background, enforcing concurrency limits and identifying long-running vs. blocking operations. Delegation categories add a semantic layer over model routing, allowing tasks to be categorized (e.g., visual-engineering, ultrabrain, artistry) with automatic tier, temperature, and thinking budget configuration. An auto-update module implements silent version checking and background updates. A delegation-enforcer middleware ensures model parameters are always present in Task/Agent calls, with support for forceInherit to bypass model routing for non-Claude providers. Documentation (AGENTS.md) provides integration guides and API references for these new capabilities.

src/features · high confidence

New interop layer with gated MCP bridge and artifact-based handoffs

A new interop subsystem has been added to enable communication between OMC and OMX. This includes an MCP bridge (mcp-bridge.ts) that exposes tools for sending tasks and messages, gated by environment variables (OMX\_OMC\_INTEROP\_ENABLED, OMC\_INTEROP\_TOOLS\_ENABLED, OMX\_OMC\_INTEROP\_MODE) to restrict direct-write capabilities to 'active' mode. The shared-state layer (shared-state.ts) now supports artifact handoffs for large task descriptions, results, and message content, storing them as files when they exceed a size threshold while keeping small data inline. An OMX team state layer (omx-team-state.ts) provides read/write access to native OMX team directories. The implementation also fixes workspace-root resolution for multi-repo setups, ensuring interop state is written to the workspace root's .omc/ directory rather than a sub-repo's .omc/ directory. Comprehensive tests cover the gating logic, artifact surfacing, and workspace path resolution.

src/interop · high confidence

New notification configuration and dispatcher system

The dist/notifications directory now includes a comprehensive configuration reader and dispatcher for sending notifications to Discord, Telegram, Slack, and custom webhooks. The config module (config.js/config.d.ts) introduces named notification profiles, environment variable overrides (e.g., OMC\_DISCORD\_NOTIFIER\_BOT\_TOKEN, OMC\_TELEGRAM\_BOT\_TOKEN), and backward compatibility migration from the legacy stopHookCallbacks format. It also adds strict input validation for Discord mentions, Slack channels/usernames/mentions, and reply injection settings. The dispatcher module (dispatcher.js/dispatcher.d.ts) implements non-blocking, parallel notification sending with per-platform timeouts (10s send, 15s overall), proxy support for Telegram, and IPv4 enforcement to avoid connectivity issues. Custom integrations are supported via webhook or CLI execution.

dist/notifications · high confidence

New per-agent benchmark suites for code-reviewer and debugger agents

Added dedicated benchmark suites for the consolidated code-reviewer and debugger agents, including runner scripts, test fixtures, ground-truth definitions, and agent prompts. The code-reviewer suite evaluates the merged agent against the previous quality-reviewer prompt using fixtures covering payment logic, retry handlers, and SQL injection vulnerabilities. The debugger suite evaluates the merged agent against the previous build-fixer prompt using fixtures for TypeScript build errors, undefined state crashes, and intermittent Redis connection issues. Baseline results are stored in JSON files to track performance over time.

benchmarks · high confidence

New scripts/lib modules for hooks, HUD, and state management

This release introduces a suite of new helper modules in scripts/lib to support the hook runtime and HUD. Key additions include agent-model-config.mjs for per-agent model resolution from JSONC config, atomic-write.mjs for durable file operations with NTFS identity checks, bounded-git-timeout.mjs for nested git call ceilings, cache-occupancy.mjs for cross-platform process identity tracking, config-dir helpers (CJS, MJS, shell) for consistent path resolution, context-usage.mjs for HUD cache and transcript context parsing, encode-project-path.mjs for path sanitization, enforcement-log.mjs for shadow-enforcement auditing, force-agent-delegation-preflight.mjs for opt-in tool blocking, hook-command-normalizer.mjs for Windows/Unix command compatibility, hud-cache-wrapper.sh for statusLine caching, and hud-wrapper-template.mjs/txt for HUD package resolution. These modules provide the foundational infrastructure for the hook system's reliability, cross-platform support, and performance optimizations.

scripts/lib · high confidence

New team activity logging and task allocation policies

The team runtime now includes structured activity logging and role-aware task allocation. A new activity log module reads audit events and transforms them into categorized, human-readable entries (task, file, message, lifecycle, error) with a timeline formatter for reports. Additionally, a new allocation policy distributes tasks to workers using load balancing: uniform role pools use round-robin by load, while mixed-role pools score workers by role match and load penalty to prevent overloading.

dist/team · high confidence

New template hooks and deliverables schema for team workflows

The templates directory now includes a new deliverables schema (templates/deliverables.json) that defines file requirements and validation rules for team pipeline stages (plan, prd, exec, verify, fix). Additionally, several new hook templates have been added: code-simplifier.mjs (an opt-in stop hook for automatic code simplification), keyword-detector.mjs (detects magic keywords to invoke skills), persistent-mode.mjs (continuation enforcer for modes like ralph and autopilot), post-tool-use-failure.mjs (tracks tool failures for retry guidance), post-tool-use.mjs (processes \<remember\> tags for memory), pre-tool-use.mjs (enforces delegation and manages skill state), session-start.mjs (restores persistent modes and checks for updates), stop-continuation.mjs (simplified stop handler), and workflow-drift-guard.mjs (prevents workflow drift at stop boundaries).

templates · high confidence

New utility modules and comprehensive test coverage for core infrastructure

This release introduces a suite of new utility modules in src/utils to harden and standardize core behaviors: cache-occupancy.ts implements an atomic, privacy-bounded registry for tracking live plugin roots and preventing stale cache purges; config-dir.ts centralizes CLAUDE\_CONFIG\_DIR resolution with XDG-style fallbacks; encode-project-path.ts ensures consistent project directory encoding across platforms (fixing session search for paths with underscores or Windows drive colons); frontmatter.ts provides robust YAML-like parsing for skill metadata; jsonc.ts offers a lightweight, dependency-free JSONC parser that tolerates trailing commas and comments; and string-width.ts adds CJK-aware width calculations for correct terminal truncation. These changes are accompanied by extensive new test suites (cache-occupancy.test.ts, encode-project-path.test.ts, frontmatter.test.ts, jsonc.test.ts, paths.test.ts, string-width.test.ts) that validate cross-platform path handling, ANSI stripping, and edge-case parsing.

src/utils · high confidence

New verification module for standardized workflow checks

A new reusable verification module has been introduced to provide a single source of truth for verification requirements across the Ralph, Ultrawork, and Autopilot workflows. This module standardizes the verification process by offering pre-defined checks (such as build, test, lint, and functionality) and allowing teams to define custom protocols with specific evidence collection and validation rules. Users can now create verification checklists, run checks in parallel or sequentially, and generate human-readable reports in multiple formats, ensuring consistent evidence collection and approval gates across all major OMC workflows.

src/features/verification · high confidence

OpenClaw integration adds gateway configuration, event deduplication, and shell-escape security

The dist/openclaw distribution now includes the core OpenClaw integration modules. The config module reads and caches settings from \~/.claude/omc\_config.openclaw.json, gating activation on the OMC\_OPENCLAW environment variable and supporting both HTTP and command-type gateways. A new deduplication layer suppresses stale lifecycle events (such as session-starts arriving after a stop) within a 60-second window to prevent redundant alerts. The dispatcher module handles gateway communication with a 10-second timeout, enforces HTTPS for remote URLs, and uses shell-escaping for command gateways to prevent injection. The main entry point enriches hook context with reply channel details and captures fresh tmux pane content for stop/session-end events.

dist/openclaw · high confidence

OpenClaw webhook gateway integration with deduplication and tmux pane capture

The OpenClaw integration now supports configurable webhook and command gateways, allowing lifecycle events (session-start, stop, session-end) to trigger external HTTP endpoints or local shell commands via a new config file (omc\_config.openclaw.json). To prevent notification noise, the system includes a deduplication layer that suppresses late-arriving lifecycle events within a 60-second window after a terminal state, and uses delta-only tmux pane capture to forward only fresh output to gateways, avoiding stale scrollback alerts.

src/openclaw · high confidence

Ported boulder-state module for active work plan tracking

The boulder-state feature has been ported from oh-my-opencode, introducing a new module to manage the active work plan state. This includes constants for state directories (\.omc\), plan storage (\.omc/plans\), and notepads, along with storage operations to read, write, and clear the \boulder.json\ state file. It also provides utilities to find planner plans, track checkbox progress in Markdown files, and manage session IDs for active plans.

dist/features/boulder-state · high confidence

SDK-compatible command expansion utilities

The src/commands/index.ts module now provides programmatic access to slash commands for SDK integration. Users can discover available commands via listCommands or getAllCommands, retrieve specific command details with getCommand, and expand command templates with arguments using expandCommand or expandCommandPrompt. The system respects the CLAUDE\_CONFIG\_DIR environment variable for locating user-defined commands while falling back to packaged defaults, enabling seamless integration with the Claude Agent SDK.

src/commands · high confidence

Session history search feature added

A new session history search capability has been introduced, allowing users to query past session transcripts. The implementation in \src/features/session-history-search\ provides the core logic and type definitions for searching across project transcripts, legacy transcripts, and OMC session summaries/replays. It supports filtering by query string, time range (since), session ID, project, and case sensitivity, and returns matches with context excerpts.

src/features/session-history-search · high confidence

Ship complete session friction report plugin runtime

The \dist/features/session-friction-report\ module is now included in the distribution, providing the \generateSessionFrictionReport\ function and its associated TypeScript types (\SessionFrictionReport\, \SessionFrictionSession\, \SessionFrictionSignal\). This runtime implementation enables the analysis of session data by scanning for project transcripts, legacy transcripts, and OMC session summaries/replays to calculate friction scores and signals based on metrics like error rates, idle gaps, and tool usage.

dist/features/session-friction-report · high confidence

Ultragoal supports multi-plan workspaces with opt-in parallel runs

The Ultragoal runtime now supports managing multiple independent plans within a single workspace, enabling safe parallel execution across multi-repo setups. By default, Ultragoal retains its legacy single-plan layout for backward compatibility, but users can opt into the new multi-plan structure by providing a \planId\ via the \--plan-id\ CLI flag or by enabling \autoPlanId\ to automatically generate unique identifiers. When multiple plans exist, commands require an explicit plan ID to resolve ambiguity, ensuring that artifacts like goals, ledgers, and briefs are correctly isolated under \.omc/ultragoal/plans/{planId}/\.

dist/ultragoal · high confidence

Unified delegation router with configurable external models

The delegation-routing module now provides a unified router that determines which provider or tool to use for a given agent role based on configuration. It introduces a precedence system: explicit tool invocations take priority, followed by configured routing (if enabled), a default heuristic mapping role categories to Claude subagents, and finally a default provider. The router now supports configurable fallback chains (e.g., \["claude:explore", "codex:gpt-5"\]) and includes logic to handle deprecated MCP providers (Codex/Gemini) by issuing warnings and falling back to Claude Task. It also normalizes legacy role aliases to canonical names and exposes constants for default delegation configuration and role category defaults.

dist/features/delegation-routing · high confidence

Workspace checkpointing for snapshot and rollback

Added a new checkpoint feature that allows users to snapshot the entire working tree (including untracked files) as a git shadow commit and restore it later. This enables safe rollback of autonomous runs by capturing the state under refs/omc/checkpoints/ without modifying HEAD or the real index. The implementation provides functions to create checkpoints with labels, list existing checkpoints, check if the worktree is dirty, and rollback to a specific checkpoint (with a force option to discard uncommitted changes).

dist/features/checkpoint · high confidence

Workspace snapshot and rollback for autonomous runs

A new checkpoint system allows the application to capture the entire working tree (including untracked files) as a lightweight git shadow commit without altering the user's HEAD or index. This enables safe rollback capabilities for autonomous runs: users can restore the workspace to a previous state, with the system automatically cleaning up new files and refusing to discard uncommitted local changes unless the --force flag is explicitly provided.

src/features/checkpoint · high confidence

Security

Python REPL bridge now enforces strict security validations and sandbox boundaries

The Python REPL tool now includes a new bridge-manager that enforces security validations when spawning and managing the underlying Python process. This includes anti-poisoning checks to verify session IDs, anti-hijack protections for socket paths, and process identity verification to guard against PID reuse. Additionally, the tool now explicitly documents and enforces sandbox boundaries, blocking imports, file I/O, and dynamic code execution to ensure safe in-memory data analysis.

dist/tools/python-repl · high confidence

Behavioural changes

Added runtime session state and locking artifacts

The system now includes generated runtime state files for a specific agent session, including a JSON state file tracking the session's lifecycle (status, activity, tool usage) and associated file-locking artifacts to manage concurrent access. These files represent the internal state of an active agent session running a bash tool.

.gjc · medium confidence

Agent addressability contract and projection fixtures added to dist

The build now tracks generated distribution modules in git. This change adds the compiled JavaScript and TypeScript declaration files for the new agent addressability contract (dist/features/agent-addressability), which implements stable discoverability and exact addressing for background agents, alongside the corresponding contract tests. It also adds the compiled projection fixture tests (dist/projection/\_\tests\\_/fixtures.test.js), which verify the integrity of prompt projection golden files and normalized body fixtures.

dist/features/agent-addressability, dist/projection · high confidence

Bundled skills now adapt to available AI providers and respect user-defined ambiguity thresholds

The built-in skills feature now detects which AI providers (Claude, Codex, Gemini, Grok, and Antigravity) are available on the user's system and dynamically adjusts its guidance—such as recommending Codex-specific commands for the deep-interview, plan, and Ralph skills when Codex is installed. Additionally, the deep-interview skill now reads the \ambiguityThreshold\ from the user's \.claude/settings.json\ (project-level) or \\~/.claude/settings.json\ (profile-level), replacing previously hardcoded 20% / 0.2 values so that execution behavior aligns with the user's configured preferences.

dist/features/builtin-skills · high confidence

Centralized constants for modes, tool categories, and hook events

The application now uses a unified constants registry to define mode names (such as autopilot, ralph, and ultrawork), tool categories (including lsp, ast, python, and new additions like antigravity, shared-memory, deepinit, and wiki), and hook events (such as PreToolUse and SessionStart). This change replaces scattered string literals with a single source of truth, ensuring consistent naming across the codebase and providing strongly-typed identifiers for these core configuration elements.

src/constants · high confidence

Centralized model routing and configurable plan output paths

The configuration system has been refactored to centralize model ID management and introduce configurable plan output paths. Model defaults are now resolved dynamically via environment variables (OMC\_MODEL\_HIGH/MEDIUM/LOW) with built-in fallbacks, replacing hardcoded agent-specific model IDs in the default configuration. A new intelligent routing system is enabled by default, allowing per-agent tier overrides (e.g., architect/planner to HIGH, explore/writer to LOW) and supporting forceInherit for non-Claude providers. Additionally, users can now customize where autopilot and open-questions plan files are saved via the planOutput configuration, with safe path sanitization and template support.

src/config · high confidence

Directory diagnostics now use a dual strategy with LSP fallback

The diagnostics tool in dist/tools/diagnostics now supports a dual strategy for checking TypeScript/JavaScript projects. It primarily uses the TypeScript compiler (tsc --noEmit) for fast, comprehensive checks, but falls back to an LSP-based aggregation when tsc is unavailable or unsuitable. This change introduces new entry points (runDirectoryDiagnostics, runLspAggregatedDiagnostics, runTscDiagnostics) and result types (DirectoryDiagnosticResult, LspAggregationResult, TscResult) that standardize output across both strategies, including error/warning counts, file-level diagnostics, and installation hints for missing language servers.

dist/tools/diagnostics · high confidence

Introduce artifact handoff system and expand configuration schema

This change introduces a new artifact-handoff mechanism in src/shared/artifact-descriptor.ts, allowing the system to pass content to agents either inline (for small payloads) or via file descriptors (for larger artifacts) based on a configurable byte threshold. It also significantly expands the shared configuration types in src/shared/types.ts: the ModelType enum now includes 'fable', AgentConfig supports optional/disallowed tools and default models, and a new AutopilotConfigBlock defines structured profiles for planning, execution backends, and QA cycles. Additionally, the PluginConfig gains sections for intelligent model routing (with tier-based selection, escalation, and alias overrides), external model support, company-context MCP contracts, and keyword-detector opt-outs, while renaming several legacy agent keys to reflect the current product identity.

src/shared · high confidence

LSP client now supports configurable request timeouts and Windows shell execution

The LSP client implementation in dist/tools/lsp now allows users to override the default 15-second request timeout via the OMC\_LSP\_TIMEOUT\_MS environment variable, providing better control over server responsiveness. Additionally, the client now correctly spawns language server processes on Windows using shell execution (shell: true) to resolve ENOENT errors with npm-installed .cmd scripts, ensuring reliable server startup on that platform.

dist/tools/lsp · high confidence

New planning artifact parsing and execution hint extraction

The dist/planning module now includes new artifact-names and artifacts utilities that standardize how planning files (PRDs and test specs) are identified and validated. These changes introduce structured parsing for artifact filenames (supporting kinds like 'prd', 'test-spec', 'deep-interview', and 'deep-interview-autoresearch') and implement logic to verify planning completeness by checking for required sections in the latest PRD and its matching test spec. Additionally, the system can now extract embedded launch hints from PRD files to determine approved execution commands for team or ralph modes, handling complex flag parsing and worker count extraction.

dist/planning · high confidence

New shared constants registry and expanded hook lifecycle tests

The dist/hooks package now includes a centralized constants registry (dist/constants) that defines canonical string values for modes (e.g., autopilot, team), tool categories (e.g., lsp, codex), and hook events (e.g., SessionStart, PreToolUse), replacing scattered literals. Additionally, the package ships new regression tests for the hook bridge: one ensures AskUserQuestion notifications fire at PreToolUse rather than PostToolUse, and another validates the background process guard logic, including enforcing max background task limits and permission checks for executor tasks. Also in this area: Improved keyword detection for mode invocations and regression fixes.

dist/hooks, dist/providers · high confidence

Rebrand to Oh-My-ClaudeCode and add delegation and hook examples

The examples directory has been updated to reflect the product rebrand from 'Oh-My-Claude-Sisyphus' to 'Oh-My-ClaudeCode', updating all import paths (e.g., \oh-my-claudecode\), session creation functions (\createOmcSession\), and system prompt helpers (\getOmcSystemPrompt\). The default agent configuration has shifted from 'sisyphus' to 'omc', and specific agent models have been updated (e.g., \claude-sonnet-5\, \claude-opus-4-6\). Additionally, two new example files have been introduced: \delegation-enforcer-demo.ts\ demonstrates the automatic injection of model parameters for agent tasks and integration with pre-tool-use hooks, while \hooks.json\ provides a schema-compliant configuration for common automation patterns like auto-formatting, linting, and secret detection.

examples · high confidence

Rebuilt agent definitions with modular structure and expanded roles

The agent system in dist/agents has been rebuilt to use a modular file structure, with individual definitions for agents like analyst, architect, critic, designer, document-specialist, executor, explore, qa-tester, scientist, and tracer, alongside a consolidated definitions.js that registers all agents (including debugger, verifier, test-engineer, security-reviewer, code-reviewer, git-master, and code-simplifier) and provides the main orchestrator prompt. This change introduces new agent roles, standardizes metadata and prompt loading, and updates the orchestrator's available subagent list to 19 agents with explicit role disambiguation and deprecated alias mappings.

dist/agents · high confidence

Timestamped planning artifacts and canonical handoff matching

Planning outputs (PRDs and test specs) are now canonicalized with ISO timestamps in their filenames (e.g., prd-20260502T090000Z-alpha.md). The system reads artifacts from both .omc/plans and .omx/plans directories, preferring the lexicographically latest artifact across both roots. Timestamped PRDs strictly match only their corresponding timestamped test specs, while legacy un-timestamped files continue to match by slug. Planning completion gates now require both the latest PRD and its matched test spec to contain required sections (Acceptance criteria, Requirement coverage map, Unit coverage, Verification mapping).

src/planning · high confidence

Unified state management with legacy migration and stale-state cleanup

The state-manager module now standardizes state file locations to \.omc/state/{name}.json\ for local state and an XDG-aware global path for user state, while maintaining backward compatibility by reading from legacy locations (e.g., \\~/.omc/state\) when enabled. Users benefit from automatic migration of existing state files to the new standard locations, ensuring a clean transition. Additionally, the module introduces utilities to detect and deactivate stale states based on activity heartbeats and modification times, and provides cleanup functions to remove orphaned state files, improving disk hygiene and preventing issues with abandoned states.

dist/features/state-manager · high confidence

Updated default model versions and added forceInherit routing option

The built-in default for the HIGH model tier has been updated from Claude Opus 4.7 to Claude Opus 4.8, and the default Sonnet model has been upgraded from 4.5 to 4.6. Additionally, a new \forceInherit\ option has been added to the routing configuration, allowing users to bypass model routing and force sub-agents to inherit the parent session's model.

dist/config · high confidence

Workflow registry, alias resolution, and prompt projection parity

The workflow module now enforces a canonical registry and alias resolution system: legacy aliases (e.g., \release\, \psm\) route to Tier-0 targets (\omc-release\, \project-session-manager\) with session-scoped warnings, while retired aliases (e.g., \ultrawork\, \swarm\) no longer resolve. The registry defines six Tier-0 workflows (\plan\, \deep-interview\, \ralplan\, \execute\, \review\, \verify\) and four Tier-0 roles, applying risk-based gate policies (hard risks fail closed, others fail open) and a structured retirement policy. Deterministic registry projections and drift checks ensure installed skills/commands match the registry. Additionally, prompt projection parity tests verify that \docs/CLAUDE.md\ generates deterministic, digest-verified projections for \CLAUDE.md\ and \.github/CLAUDE.md\, ensuring build consistency and manifest validation.

src/workflow · high confidence

Fixes

Cross-platform process management and identity verification

The platform module now provides robust, cross-platform utilities for managing and verifying process lifecycles. It introduces precise process start-time identity checks to detect PID reuse, including high-precision DMTF timestamp parsing for Windows and locale-safe probes for macOS. Process termination is now safer and more reliable: owned process groups on Unix are terminated by group ID with strict identity verification (preventing accidental termination of unrelated processes), while Windows uses a fallback strategy beyond WMIC. The module also consolidates process existence checks with proper EPERM handling and adds a centralized platform detection utility.

src/platform · high confidence

New standalone hook library with robust state, I/O, and platform-specific fixes

The templates/hooks/lib directory now includes a comprehensive set of self-contained JavaScript modules that power the hook runtime. These changes introduce atomic file writes with emergency journaling to prevent data corruption, bounded Git timeouts to prevent indefinite hangs, and platform-specific stdin reading with strict timeouts to resolve Linux and Windows freeze issues. The library also adds a new config-dir module that respects the CLAUDE\_CONFIG\_DIR environment variable, a model-routing-override message for non-standard providers, and hardened precompact restore/publisher logic with canonical path verification and integer mtime normalization. Additionally, it includes a state-lock template that fails closed if unprovisioned, a skill-entitlements visibility check, and a workflow-profile-runtime that validates autopilot stage sequences and hashes. These modules collectively fix session state isolation, restore provenance, and improve reliability across Windows, Linux, and macOS.

templates/hooks · high confidence

Test coverage

Added comprehensive test coverage for state management, path resolution, and safety guards; Added contract-authored tests for Graph Core descriptor validation and scheduler logic; Added integration tests for custom webhook and CLI dispatch; Added integration tests for state cancellation and deepinit manifest scanning; Added prompt validation test helpers; Added regression tests for Jira provider CLI flags and prompt injection context; Added regression tests for Windows compatibility and config directory portability in skills; Added regression tests for skill markdown portability and correctness; Added reproduction script for state-lock owner-reclaim issue; Added test coverage for AST tools, skills tools, and trace tools; Added test coverage for CLI commands; Added test coverage for HUD elements and utilities; Added test coverage for agent contracts, registry, and handoffs; Added test coverage for autoresearch contracts, runtime, and setup validation; Added test coverage for graph runtime v2 components; Added test coverage for notification system components; Added test coverage for team activity logging, task allocation, and API interop; Added test coverage for the Mnemosyne skill-learning subsystem; Added test coverage for the learner hook bridge, parser, and transliteration logic; Added test coverage for the rate-limit-wait daemon and quota recovery logic; Added test fixtures for hook lifecycle and transcript validation; Added tests for CLI ask and autoresearch-guided modules; Added tests for CLI capabilities locking, doctor team routing, and team role shorthand; Added tests for Graph Core descriptor validation and approval gates; Added tests for HUD agent kind classification and background task management; Added tests for LSP client devcontainer support, eviction logic, and byte-length handling; Added tests for LSP diagnostics aggregation; Added tests for MCP prompt injection guards, tool-list drift, shutdown, and team cleanup; Added tests for Ralphthon CLI, Orchestrator, and PRD modules; Added tests for agent registry, advisory output contracts, and artifact descriptor handoffs; Added tests for atomic write and mode state I/O; Added tests for autoresearch contract parsing and runtime outcome decisions; Added tests for cache occupancy, path encoding, and frontmatter parsing; Added tests for checkpoint, Jev shadow routing, and magic keywords; Added tests for config loader and model detection logic; Added tests for config loader, model detection, and plan output paths; Added tests for config resolution, deduplication, and dead-pane guard; Added tests for delegation routing fallback and deprecation handling; Added tests for delegation routing resolver fallback logic; Added tests for interop bridge gating, artifact handling, and workspace path resolution; Added tests for magic keywords feature; Added tests for model routing and prompt adaptation; Added tests for multi-repo ultragoal artifact anchoring; Added tests for notification config merging and validation; Added tests for planning artifact reading and completeness validation; Added tests for plugin-patterns validation and session-end cleanup; Added tests for process identity and termination utilities; Added tests for python\_repl bridge cleanup, sandbox enforcement, and documentation parity; Added tests for rate-limit-wait daemon and integration flows; Added tests for state-manager cache behavior; Added tests for team activity logging, task allocation, and API cleanup behavior; Added tests for the alias-retirement closure and policy logic; Added tests for the auto-learner and skill matcher modules; Added tests for the learner hook bridge, parser, and transliteration map; Added tests for ultragoal multi-repo workspace artifact handling; Added tests for utility functions in dist/utils; Added unit tests for Git provider implementations and detection logic; Added unit tests for agent and command node executors; Comprehensive test coverage for hooks system; Expanded Lookout test coverage for workspace and briefing rules; Expanded test coverage for CLI, launch, and autoresearch subsystems; Expanded test coverage for HUD agent kind, background tasks, and usage elements; Expanded test coverage for benchmark diagnostics, harbor scenarios, budget guard, and concurrent state management; HUD test coverage for new status elements and state management; Installer CLAUDE.md handling tests added; Installer CLAUDE.md merge and transaction logic gains comprehensive regression tests; New test suite for tools directory state, memory, and wiki behavior.

Dependencies

Major version upgrade to 5.5.0 with expanded runtime and dependency support

The product has been upgraded to version 5.5.0, introducing support for Node.js versions 20 through 26. This release adds several new runtime dependencies, including the Model Context Protocol SDK, Better-SQLite3 for local storage, AJV for JSON validation, and safe-regex. It also introduces new CLI entry points (omc, omc-cli) and expands the build system with scripts for team server, bridge, and prompt generation. Test and benchmarking capabilities are enhanced with the addition of a Python benchmark environment and updated TypeScript testing tools.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 56 → 55 (-1.6)

Lenses

  • Code Health 60 → 58 (-1.7)
  • Architecture 55 → 52 (-2.8)
  • Maturity 77 → 80 (+2.4)
  • Readiness 52 → 52 (-0.2)
  • Security 76 → 61 (-14.9)
  • Performance 60 → 60 (+0.0)

Resolved (30)

  • Ambiguous HookContext types. There is a generic src.shared.types.HookContext (focused on tool usage) and a specific src.hooks.learner.types.HookContext (focused on skill learning context). While distinct in domain, the naming collision (HookContext) in the public API surface is confusing. Consumers importing HookContext may not know which one they are getting without deep path inspection.
  • Critical CVE: [GHSA redacted] (bun.lock)
  • Critical CVE: [GHSA redacted] (bun.lock)
  • Decision is a single sentence with no context (why replace heuristics) and no consequences/trade-offs (docs/adr/03665-jev-degradation-contract.md)
  • Documentation: no project overview (docs/AGENTS.md)
  • Duplicate configuration types for Autopilot. AutopilotConfigBlock (in shared types) and AutopilotConfig (in hooks/autopilot/types) contain nearly identical properties for controlling iteration limits, QA, and validation. This suggests two different configuration schemas are being used or maintained in parallel, likely for different layers (e.g., static config vs runtime state).
  • High CVE: [GHSA redacted] (bun.lock)
  • High CVE: [GHSA redacted] (bun.lock)
  • High CVE: [GHSA redacted] (bun.lock)
  • High CVE: [GHSA redacted] (bun.lock)
  • Hotspot: scripts/lib/atomic-write.mjs (scripts/lib/atomic-write.mjs)
  • Hotspot: scripts/release.ts (scripts/release.ts)
  • Hotspot: src/hooks/autopilot/runtime-insight.ts (src/hooks/autopilot/runtime-insight.ts)
  • Hotspot: src/hooks/mode-registry/index.ts (src/hooks/mode-registry/index.ts)
  • Hotspot: src/hooks/session-end/action-runner.ts (src/hooks/session-end/action-runner.ts)
  • Hotspot: src/hooks/session-end/cleanup-manifest.ts (src/hooks/session-end/cleanup-manifest.ts)
  • Hotspot: src/hooks/team-dispatch-hook.ts (src/hooks/team-dispatch-hook.ts)
  • Hotspot: templates/hooks/lib/atomic-write.mjs (templates/hooks/lib/atomic-write.mjs)
  • Medium CVE: [GHSA redacted] (bun.lock)
  • Medium CVE: [GHSA redacted] (bun.lock)
  • …and 10 more

New (95)

  • ADR declares no status (docs/adr/03665-jev-degradation-contract.md)
  • ADR declares no status (docs/adr/03672-env-activated-active-mode.md)
  • ADR has no Context section (docs/adr/03487-named-autopilot-stage-profiles.md)
  • ADR has no Context section (docs/adr/03570-graph-core-contract.md)
  • ADR has no Context section (docs/adr/03664-ralph-prd-criterion-amendment.md)
  • ADR not followed: ADR 03570: Graph Core Contract (Descriptor + Pure Scheduler) (docs/adr/03570-graph-core-contract.md)
  • ADR not followed: ADR 03570: Graph Core Contract (Descriptor + Pure Scheduler) (docs/adr/03570-graph-core-contract.md)
  • Classify ADR enforcement: ADR 03487: Named Autopilot Stage Profiles (docs/adr/03487-named-autopilot-stage-profiles.md)
  • Classify ADR enforcement: ADR 03570: Graph Core Contract (Descriptor + Pure Scheduler) (docs/adr/03570-graph-core-contract.md)
  • Classify ADR enforcement: ADR 03664: Ralph PRD Evidence-Preserving Criterion Amendment (docs/adr/03664-ralph-prd-criterion-amendment.md)
  • Classify ADR enforcement: Env-activated active mode: one env line enables every judgment point (docs/adr/03672-env-activated-active-mode.md)
  • Classify ADR enforcement: Jev integration degrades to heuristics (docs/adr/03665-jev-degradation-contract.md)
  • Classify ADR enforcement: Script-side judgment channel: subprocess over stdin JSON (docs/adr/03671-script-side-judgment-channel.md)
  • Critical CVE: [GHSA redacted] (package-lock.json)
  • Critical CVE: [GHSA redacted] (package-lock.json)
  • Deprecated: eslint (package.json)
  • Disclosure policy routes reports to a public channel
  • High CVE: [GHSA redacted] (package-lock.json)
  • High CVE: [GHSA redacted] (package-lock.json)
  • High CVE: [GHSA redacted] (package-lock.json)
  • …and 75 more

Changes since last survey

  • 300 commits — 215 feature/other, 85 fixes

By area

  • (repo) — 96 commits
  • .github/generated-artifact-authorizations.json — 84 commits
  • inventory/inventory-graph.json — 36 commits
  • src/hooks — 15 commits
  • src/team — 14 commits
  • .github/release-body.md — 7 commits
  • src/cli — 7 commits
  • (root) — 6 commits
  • dist/team — 6 commits
  • dist/tests — 4 commits
  • dist/cli — 4 commits
  • src/utils — 4 commits
  • src/tests — 3 commits
  • dist/hooks — 2 commits
  • src/autoresearch — 2 commits
  • src/installer — 2 commits
  • src/notifications — 2 commits
  • bridge/claude-md-coordinator.cjs — 1 commit
  • bridge/cli.cjs — 1 commit
  • dist/utils — 1 commit

Notable commits

  • fix: Merge pull request #4407 from rudycelekli/fix/rules-trailing-comments-20261016
  • fix: Merge pull request #4484 from Yeachan-Heo/fix/expiresAt-dev
  • fix: chore(release): sign v5.7.7 fixture fix
  • fix: chore(release): update inventory graph for v5.7.6 with expiresAt fix
  • fix: ci: fix canonical expiry format for PR #4456 authorization (#4480)
  • fix: ci: fix canonical expiry format for PR #4456 authorization on dev
  • fix: fix(#4422): update expectations and regenerate artifacts after removing merge-readiness MCP tools
  • fix: fix(agents): read agent frontmatter by line-anchored delimiters and after a BOM (#4451)
  • fix: fix(auto-slash-command): keep the plugin namespace when parsing slash commands (#4450)
  • fix: fix(autoresearch): accept a leading UTF-8 BOM in sandbox.md frontmatter (#4452)
  • fix: fix(autoresearch): keep quotes inside an unquoted sandbox.md value (#4411)
  • fix: fix(ci): canonicalize generated artifact authorizations
  • fix: fix(ci): correct canonical UTC timestamp for PR #4422 authorization (#4428)
  • fix: fix(cli): reject non-integer values for wait and session numeric options (#4409)
  • fix: fix(commands): parse CRLF frontmatter in command files (#4402)
  • fix: fix(debug): read OMC_DEBUG through one shared convention (#4508)
  • fix: fix(dev): regenerate inventory graph to match current file state (#4486)
  • fix: fix(doctor): ignore empty OMC_SKIP_HOOKS entries (#4417)
  • fix: fix(factcheck): match strict project globs literally (#4416)
  • fix: fix(factory): validate listen --port as an integer in 0-65535 (#4420)
  • …and 280 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.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-claudecode 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 26 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 726fa45e081a65f8e971ef291dbf0d9cecf24897 — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.34+preprod-c12eef3a1477.