Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

Resolve claw-code main merge conflicts

Yeachan-Heof9cb42fb44bf
diff --git a/rust/crates/commands/src/lib.rs b/rust/crates/commands/src/lib.rs
index f038a002..a02322de 100644
--- a/rust/crates/commands/src/lib.rs
+++ b/rust/crates/commands/src/lib.rs
@@ -243,7 +243,7 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
},
SlashCommandSpec {
name: "skills",
- aliases: &[],
+ aliases: &["skill"],
summary: "List, install, or invoke available skills",
argument_hint: Some("[list|install <path>|help|<skill> [args]]"),
resume_supported: true,
@@ -1312,7 +1312,7 @@ pub fn validate_slash_command_input(
"agents" => SlashCommand::Agents {
args: parse_list_or_help_args(command, remainder)?,
},
- "skills" => SlashCommand::Skills {
+ "skills" | "skill" => SlashCommand::Skills {
args: parse_skills_args(remainder.as_deref())?,
},
"doctor" => {
@@ -1975,9 +1975,9 @@ enum DefinitionScope {
impl DefinitionScope {
fn label(self) -> &'static str {
match self {
- Self::Project => "Project (.claw)",
- Self::UserConfigHome => "User ($CLAW_CONFIG_HOME)",
- Self::UserHome => "User (~/.claw)",
+ Self::Project => "Project roots",
+ Self::UserConfigHome => "User config roots",
+ Self::UserHome => "User home roots",
}
}
}
@@ -2548,6 +2548,14 @@ fn discover_definition_roots(cwd: &Path, leaf: &str) -> Vec<(DefinitionSource, P
);
}
+ if let Ok(claude_config_dir) = env::var("CLAUDE_CONFIG_DIR") {
+ push_unique_root(
+ &mut roots,
+ DefinitionSource::UserClaude,
+ PathBuf::from(claude_config_dir).join(leaf),
+ );
+ }
+
if let Some(home) = env::var_os("HOME") {
let home = PathBuf::from(home);
push_unique_root(
@@ -2581,6 +2589,18 @@ fn discover_skill_roots(cwd: &Path) -> Vec<SkillRoot> {
ancestor.join(".claw").join("skills"),
SkillOrigin::SkillsDir,
);
+ push_unique_skill_root(
+ &mut roots,
+ DefinitionSource::ProjectClaw,
+ ancestor.join(".omc").join("skills"),
+ SkillOrigin::SkillsDir,
+ );
+ push_unique_skill_root(
+ &mut roots,
+ DefinitionSource::ProjectClaw,
+ ancestor.join(".agents").join("skills"),
+ SkillOrigin::SkillsDir,
+ );
push_unique_skill_root(
&mut roots,
DefinitionSource::ProjectCodex,
@@ -2653,6 +2673,12 @@ fn discover_skill_roots(cwd: &Path) -> Vec<SkillRoot> {
home.join(".claw").join("skills"),
SkillOrigin::SkillsDir,
);
+ push_unique_skill_root(
+ &mut roots,
+ DefinitionSource::UserClaw,
+ home.join(".omc").join("skills"),
+ SkillOrigin::SkillsDir,
+ );
push_unique_skill_root(
&mut roots,
DefinitionSource::UserClaw,
@@ -2677,6 +2703,12 @@ fn discover_skill_roots(cwd: &Path) -> Vec<SkillRoot> {
home.join(".claude").join("skills"),
SkillOrigin::SkillsDir,
);
+ push_unique_skill_root(
+ &mut roots,
+ DefinitionSource::UserClaude,
+ home.join(".claude").join("skills").join("omc-learned"),
+ SkillOrigin::SkillsDir,
+ );
push_unique_skill_root(
&mut roots,
DefinitionSource::UserClaude,
@@ -2685,6 +2717,29 @@ fn discover_skill_roots(cwd: &Path) -> Vec<SkillRoot> {
);
}
+ if let Ok(claude_config_dir) = env::var("CLAUDE_CONFIG_DIR") {
+ let claude_config_dir = PathBuf::from(claude_config_dir);
+ let skills_dir = claude_config_dir.join("skills");
+ push_unique_skill_root(
+ &mut roots,
+ DefinitionSource::UserClaude,
+ skills_dir.clone(),
+ SkillOrigin::SkillsDir,
+ );
+ push_unique_skill_root(
+ &mut roots,
+ DefinitionSource::UserClaude,
+ skills_dir.join("omc-learned"),
+ SkillOrigin::SkillsDir,
+ );
+ push_unique_skill_root(
+ &mut roots,
+ DefinitionSource::UserClaude,
+ claude_config_dir.join("commands"),
+ SkillOrigin::LegacyCommandsDir,
+ );
+ }
+
roots
}
@@ -3467,10 +3522,11 @@ fn render_skills_usage(unexpected: Option<&str>) -> String {
let mut lines = vec![
"Skills".to_string(),
" Usage /skills [list|install <path>|help|<skill> [args]]".to_string(),
+ " Alias /skill".to_string(),
" Direct CLI claw skills [list|install <path>|help|<skill> [args]]".to_string(),
" Invoke /skills help overview -> $help overview".to_string(),
" Install root $CLAW_CONFIG_HOME/skills or ~/.claw/skills".to_string(),
- " Sources .claw/skills, ~/.claw/skills, legacy /commands".to_string(),
+ " Sources .claw/skills, .omc/skills, .agents/skills, .codex/skills, .claude/skills, ~/.claw/skills, ~/.omc/skills, ~/.claude/skills/omc-learned, ~/.codex/skills, ~/.claude/skills, legacy /commands".to_string(),
];
if let Some(args) = unexpected {
lines.push(format!(" Unexpected {args}"));
@@ -3484,10 +3540,24 @@ fn render_skills_usage_json(unexpected: Option<&str>) -> Value {
"action": "help",
"usage": {
"slash_command": "/skills [list|install <path>|help|<skill> [args]]",
+ "aliases": ["/skill"],
"direct_cli": "claw skills [list|install <path>|help|<skill> [args]]",
"invoke": "/skills help overview -> $help overview",
"install_root": "$CLAW_CONFIG_HOME/skills or ~/.claw/skills",
- "sources": [".claw/skills", "legacy /commands", "legacy fallback dirs still load automatically"],
+ "sources": [
+ ".claw/skills",
+ ".omc/skills",
+ ".agents/skills",
+ ".codex/skills",
+ ".claude/skills",
+ "~/.claw/skills",
+ "~/.omc/skills",
+ "~/.claude/skills/omc-learned",
+ "~/.codex/skills",
+ "~/.claude/skills",
+ "legacy /commands",
+ "legacy fallback dirs still load automatically"
+ ],
},
"unexpected": unexpected,
})
@@ -3849,8 +3919,10 @@ mod tests {
use runtime::{
CompactionConfig, ConfigLoader, ContentBlock, ConversationMessage, MessageRole, Session,
};
+ use std::ffi::OsString;
use std::fs;
use std::path::{Path, PathBuf};
+ use std::sync::{Mutex, OnceLock};
use std::time::{SystemTime, UNIX_EPOCH};
fn temp_dir(label: &str) -> PathBuf {
@@ -3861,6 +3933,18 @@ mod tests {
std::env::temp_dir().join(format!("commands-plugin-{label}-{nanos}"))
}
+ fn env_lock() -> &'static Mutex<()> {
+ static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+ LOCK.get_or_init(|| Mutex::new(()))
+ }
+
+ fn restore_env_var(key: &str, original: Option<OsString>) {
+ match original {
+ Some(value) => std::env::set_var(key, value),
+ None => std::env::remove_var(key),
+ }
+ }
+
fn write_external_plugin(root: &Path, name: &str, version: &str) {
fs::create_dir_all(root.join(".claude-plugin")).expect("manifest dir");
fs::write(
@@ -4275,6 +4359,7 @@ mod tests {
assert!(help.contains("aliases: /plugins, /marketplace"));
assert!(help.contains("/agents [list|help]"));
assert!(help.contains("/skills [list|install <path>|help|<skill> [args]]"));
+ assert!(help.contains("aliases: /skill"));
assert_eq!(slash_command_specs().len(), 141);
assert!(resume_supported_slash_commands().len() >= 39);
}
@@ -4517,10 +4602,10 @@ mod tests {
assert!(report.contains("Agents"));
assert!(report.contains("2 active agents"));
- assert!(report.contains("Project (.claw):"));
+ assert!(report.contains("Project roots:"));
assert!(report.contains("planner · Project planner · gpt-5.4 · medium"));
- assert!(report.contains("User (~/.claw):"));
- assert!(report.contains("(shadowed by Project (.claw)) planner · User planner"));
+ assert!(report.contains("User home roots:"));
+ assert!(report.contains("(shadowed by Project roots) planner · User planner"));
assert!(report.contains("verifier · Verification agent · gpt-5.4-mini · high"));
let _ = fs::remove_dir_all(workspace);
@@ -4628,11 +4713,11 @@ mod tests {
assert!(report.contains("Skills"));
assert!(report.contains("3 available skills"));
- assert!(report.contains("Project (.claw):"));
+ assert!(report.contains("Project roots:"));
assert!(report.contains("plan · Project planning guidance"));
assert!(report.contains("deploy · Legacy deployment guidance · legacy /commands"));
- assert!(report.contains("User (~/.claw):"));
- assert!(report.contains("(shadowed by Project (.claw)) plan · User planning guidance"));
+ assert!(report.contains("User home roots:"));
+ assert!(report.contains("(shadowed by Project roots) plan · User planning guidance"));
assert!(report.contains("help · Help guidance"));
let _ = fs::remove_dir_all(workspace);
@@ -4704,6 +4789,7 @@ mod tests {
let help = handle_skills_slash_command_json(Some("help"), &workspace).expect("skills help");
assert_eq!(help["kind"], "skills");
assert_eq!(help["action"], "help");
+ assert_eq!(help["usage"]["aliases"][0], "/skill");
assert_eq!(
help["usage"]["direct_cli"],
"claw skills [list|install <path>|help|<skill> [args]]"
@@ -4732,8 +4818,12 @@ mod tests {
super::handle_skills_slash_command(Some("--help"), &cwd).expect("skills help");
assert!(skills_help
.contains("Usage /skills [list|install <path>|help|<skill> [args]]"));
+ assert!(skills_help.contains("Alias /skill"));
assert!(skills_help.contains("Invoke /skills help overview -> $help overview"));
assert!(skills_help.contains("Install root $CLAW_CONFIG_HOME/skills or ~/.claw/skills"));
+ assert!(skills_help.contains(".omc/skills"));
+ assert!(skills_help.contains(".agents/skills"));
+ assert!(skills_help.contains("~/.claude/skills/omc-learned"));
assert!(skills_help.contains("legacy /commands"));
let skills_unexpected =
@@ -4744,6 +4834,7 @@ mod tests {
.expect("nested skills help");
assert!(skills_install_help
.contains("Usage /skills [list|install <path>|help|<skill> [args]]"));
+ assert!(skills_install_help.contains("Alias /skill"));
assert!(skills_install_help.contains("Unexpected install"));
let skills_unknown_help =
@@ -4752,9 +4843,87 @@ mod tests {
.contains("Usage /skills [list|install <path>|help|<skill> [args]]"));
assert!(skills_unknown_help.contains("Unexpected show"));
+ let skills_help_json =
+ super::handle_skills_slash_command_json(Some("help"), &cwd).expect("skills help json");
+ let sources = skills_help_json["usage"]["sources"]
+ .as_array()
+ .expect("skills help sources");
+ assert_eq!(skills_help_json["usage"]["aliases"][0], "/skill");
+ assert!(sources.iter().any(|value| value == ".omc/skills"));
+ assert!(sources.iter().any(|value| value == ".agents/skills"));
+ assert!(sources.iter().any(|value| value == "~/.omc/skills"));
+ assert!(sources
+ .iter()
+ .any(|value| value == "~/.claude/skills/omc-learned"));
+
let _ = fs::remove_dir_all(cwd);
}
+ #[test]
+ fn discovers_omc_skills_from_project_and_user_compatibility_roots() {
+ let _guard = env_lock().lock().expect("env lock");
+ let workspace = temp_dir("skills-omc-workspace");
+ let user_home = temp_dir("skills-omc-home");
+ let claude_config_dir = temp_dir("skills-omc-claude-config");
+ let project_omc_skills = workspace.join(".omc").join("skills");
+ let project_agents_skills = workspace.join(".agents").join("skills");
+ let user_omc_skills = user_home.join(".omc").join("skills");
+ let claude_config_skills = claude_config_dir.join("skills");
+ let claude_config_commands = claude_config_dir.join("commands");
+ let learned_skills = claude_config_dir.join("skills").join("omc-learned");
+ let original_home = std::env::var_os("HOME");
+ let original_claude_config_dir = std::env::var_os("CLAUDE_CONFIG_DIR");
+
+ write_skill(&project_omc_skills, "hud", "OMC HUD guidance");
+ write_skill(
+ &project_agents_skills,
+ "trace",
+ "Compatibility skill guidance",
+ );
+ write_skill(&user_omc_skills, "cancel", "OMC cancel guidance");
+ write_skill(
+ &claude_config_skills,
+ "statusline",
+ "Claude config skill guidance",
+ );
+ write_legacy_command(
+ &claude_config_commands,
+ "doctor-check",
+ "Claude config command guidance",
+ );
+ write_skill(&learned_skills, "learned", "Learned skill guidance");
+ std::env::set_var("HOME", &user_home);
+ std::env::set_var("CLAUDE_CONFIG_DIR", &claude_config_dir);
+
+ let report = super::handle_skills_slash_command(None, &workspace).expect("skills list");
+ assert!(report.contains("available skills"));
+ assert!(report.contains("hud · OMC HUD guidance"));
+ assert!(report.contains("trace · Compatibility skill guidance"));
+ assert!(report.contains("cancel · OMC cancel guidance"));
+ assert!(report.contains("statusline · Claude config skill guidance"));
+ assert!(report.contains("doctor-check · Claude config command guidance · legacy /commands"));
+ assert!(report.contains("learned · Learned skill guidance"));
+
+ let help =
+ super::handle_skills_slash_command_json(Some("help"), &workspace).expect("skills help");
+ let sources = help["usage"]["sources"]
+ .as_array()
+ .expect("skills help sources");
+ assert_eq!(help["usage"]["aliases"][0], "/skill");
+ assert!(sources.iter().any(|value| value == ".omc/skills"));
+ assert!(sources.iter().any(|value| value == ".agents/skills"));
+ assert!(sources.iter().any(|value| value == "~/.omc/skills"));
+ assert!(sources
+ .iter()
+ .any(|value| value == "~/.claude/skills/omc-learned"));
+
+ restore_env_var("HOME", original_home);
+ restore_env_var("CLAUDE_CONFIG_DIR", original_claude_config_dir);
+ let _ = fs::remove_dir_all(workspace);
+ let _ = fs::remove_dir_all(user_home);
+ let _ = fs::remove_dir_all(claude_config_dir);
+ }
+
#[test]
fn mcp_usage_supports_help_and_unexpected_args() {
let cwd = temp_dir("mcp-usage");
@@ -4991,7 +5160,7 @@ mod tests {
let listed = render_skills_report(
&load_skills_from_roots(&roots).expect("installed skills should load"),
);
- assert!(listed.contains("User ($CLAW_CONFIG_HOME):"));
+ assert!(listed.contains("User config roots:"));
assert!(listed.contains("help · Helpful skill"));
let _ = fs::remove_dir_all(workspace);
diff --git a/rust/crates/plugins/src/lib.rs b/rust/crates/plugins/src/lib.rs
index 3070d177..052d1bab 100644
--- a/rust/crates/plugins/src/lib.rs
+++ b/rust/crates/plugins/src/lib.rs
@@ -920,6 +920,9 @@ pub enum PluginManifestValidationError {
tool_name: String,
permission: String,
},
+ UnsupportedManifestContract {
+ detail: String,
+ },
}
impl Display for PluginManifestValidationError {
@@ -965,6 +968,7 @@ impl Display for PluginManifestValidationError {
f,
"plugin tool `{tool_name}` requiredPermission `{permission}` must be read-only, workspace-write, or danger-full-access"
),
+ Self::UnsupportedManifestContract { detail } => f.write_str(detail),
}
}
}
@@ -1594,10 +1598,73 @@ fn load_manifest_from_path(
manifest_path.display()
))
})?;
- let raw_manifest: RawPluginManifest = serde_json::from_str(&contents)?;
+ let raw_json: Value = serde_json::from_str(&contents)?;
+ let compatibility_errors = detect_claude_code_manifest_contract_gaps(&raw_json);
+ if !compatibility_errors.is_empty() {
+ return Err(PluginError::ManifestValidation(compatibility_errors));
+ }
+ let raw_manifest: RawPluginManifest = serde_json::from_value(raw_json)?;
build_plugin_manifest(root, raw_manifest)
}
+fn detect_claude_code_manifest_contract_gaps(
+ raw_manifest: &Value,
+) -> Vec<PluginManifestValidationError> {
+ let Some(root) = raw_manifest.as_object() else {
+ return Vec::new();
+ };
+
+ let mut errors = Vec::new();
+
+ for (field, detail) in [
+ (
+ "skills",
+ "plugin manifest field `skills` uses the Claude Code plugin contract; `claw` does not load plugin-managed skills and instead discovers skills from local roots such as `.claw/skills`, `.omc/skills`, `.agents/skills`, `~/.omc/skills`, and `~/.claude/skills/omc-learned`.",
+ ),
+ (
+ "mcpServers",
+ "plugin manifest field `mcpServers` uses the Claude Code plugin contract; `claw` does not import MCP servers from plugin manifests.",
+ ),
+ (
+ "agents",
+ "plugin manifest field `agents` uses the Claude Code plugin contract; `claw` does not load plugin-managed agent markdown catalogs from plugin manifests.",
+ ),
+ ] {
+ if root.contains_key(field) {
+ errors.push(PluginManifestValidationError::UnsupportedManifestContract {
+ detail: detail.to_string(),
+ });
+ }
+ }
+
+ if root
+ .get("commands")
+ .and_then(Value::as_array)
+ .is_some_and(|commands| commands.iter().any(Value::is_string))
+ {
+ errors.push(PluginManifestValidationError::UnsupportedManifestContract {
+ detail: "plugin manifest field `commands` uses Claude Code-style directory globs; `claw` slash dispatch is still built-in and does not load plugin slash command markdown files.".to_string(),
+ });
+ }
+
+ if let Some(hooks) = root.get("hooks").and_then(Value::as_object) {
+ for hook_name in hooks.keys() {
+ if !matches!(
+ hook_name.as_str(),
+ "PreToolUse" | "PostToolUse" | "PostToolUseFailure"
+ ) {
+ errors.push(PluginManifestValidationError::UnsupportedManifestContract {
+ detail: format!(
+ "plugin hook `{hook_name}` uses the Claude Code lifecycle contract; `claw` plugins currently support only PreToolUse, PostToolUse, and PostToolUseFailure."
+ ),
+ });
+ }
+ }
+ }
+
+ errors
+}
+
fn plugin_manifest_path(root: &Path) -> Result<PathBuf, PluginError> {
let direct_path = root.join(MANIFEST_FILE_NAME);
if direct_path.exists() {
@@ -2517,6 +2584,37 @@ mod tests {
let _ = fs::remove_dir_all(root);
}
+ #[test]
+ fn load_plugin_from_directory_rejects_claude_code_manifest_contracts_with_guidance() {
+ let root = temp_dir("manifest-claude-code-contract");
+ write_file(
+ root.join(MANIFEST_FILE_NAME).as_path(),
+ r#"{
+ "name": "oh-my-claudecode",
+ "version": "4.10.2",
+ "description": "Claude Code plugin manifest",
+ "hooks": {
+ "SessionStart": ["scripts/session-start.mjs"]
+ },
+ "agents": ["agents/*.md"],
+ "commands": ["commands/**/*.md"],
+ "skills": "./skills/",
+ "mcpServers": "./.mcp.json"
+}"#,
+ );
+
+ let error = load_plugin_from_directory(&root)
+ .expect_err("Claude Code plugin manifest should fail with guidance");
+ let rendered = error.to_string();
+ assert!(rendered.contains("field `skills` uses the Claude Code plugin contract"));
+ assert!(rendered.contains("field `mcpServers` uses the Claude Code plugin contract"));
+ assert!(rendered.contains("field `agents` uses the Claude Code plugin contract"));
+ assert!(rendered.contains("field `commands` uses Claude Code-style directory globs"));
+ assert!(rendered.contains("hook `SessionStart` uses the Claude Code lifecycle contract"));
+
+ let _ = fs::remove_dir_all(root);
+ }
+
#[test]
fn load_plugin_from_directory_rejects_missing_tool_or_command_paths() {
let root = temp_dir("manifest-paths");
diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rs
index 693e944e..fd99f4d6 100644
--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
@@ -128,6 +128,11 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
args,
output_format,
} => LiveCli::print_skills(args.as_deref(), output_format)?,
+ CliAction::Plugins {
+ action,
+ target,
+ output_format,
+ } => LiveCli::print_plugins(action.as_deref(), target.as_deref(), output_format)?,
CliAction::PrintSystemPrompt {
cwd,
date,
@@ -188,6 +193,11 @@ enum CliAction {
args: Option<String>,
output_format: CliOutputFormat,
},
+ Plugins {
+ action: Option<String>,
+ target: Option<String>,
+ output_format: CliOutputFormat,
+ },
PrintSystemPrompt {
cwd: PathBuf,
date: String,
@@ -619,6 +629,10 @@ fn format_unknown_direct_slash_command(name: &str) -> String {
message.push('\n');
message.push_str(&suggestions);
}
+ if let Some(note) = omc_compatibility_note_for_unknown_slash_command(name) {
+ message.push('\n');
+ message.push_str(note);
+ }
message.push_str("\nRun `claw --help` for CLI usage, or start `claw` and use /help.");
message
}
@@ -630,10 +644,21 @@ fn format_unknown_slash_command(name: &str) -> String {
message.push('\n');
message.push_str(&suggestions);
}
+ if let Some(note) = omc_compatibility_note_for_unknown_slash_command(name) {
+ message.push('\n');
+ message.push_str(note);
+ }
message.push_str("\n Help /help lists available slash commands");
message
}
+fn omc_compatibility_note_for_unknown_slash_command(name: &str) -> Option<&'static str> {
+ name.starts_with("oh-my-claudecode:")
+ .then_some(
+ "Compatibility note: `/oh-my-claudecode:*` is a Claude Code/OMC plugin command. `claw` does not yet load plugin slash commands, Claude statusline stdin, or OMC session hooks.",
+ )
+}
+
fn render_suggestion_line(label: &str, suggestions: &[String]) -> Option<String> {
(!suggestions.is_empty()).then(|| format!(" {label:<16} {}", suggestions.join(", "),))
}
@@ -1885,14 +1910,18 @@ impl GitWorkspaceSummary {
#[cfg(test)]
fn format_unknown_slash_command_message(name: &str) -> String {
let suggestions = suggest_slash_commands(name);
- if suggestions.is_empty() {
- format!("unknown slash command: /{name}. Use /help to list available commands.")
- } else {
- format!(
- "unknown slash command: /{name}. Did you mean {}? Use /help to list available commands.",
- suggestions.join(", ")
- )
+ let mut message = format!("unknown slash command: /{name}.");
+ if !suggestions.is_empty() {
+ message.push_str(" Did you mean ");
+ message.push_str(&suggestions.join(", "));
+ message.push('?');
+ }
+ if let Some(note) = omc_compatibility_note_for_unknown_slash_command(name) {
+ message.push(' ');
+ message.push_str(note);
}
+ message.push_str(" Use /help to list available commands.");
+ message
}
fn format_model_report(model: &str, message_count: usize, turns: u32) -> String {
@@ -3569,6 +3598,32 @@ impl LiveCli {
Ok(())
}
+ fn print_plugins(
+ action: Option<&str>,
+ target: Option<&str>,
+ output_format: CliOutputFormat,
+ ) -> Result<(), Box<dyn std::error::Error>> {
+ let cwd = env::current_dir()?;
+ let loader = ConfigLoader::default_for(&cwd);
+ let runtime_config = loader.load()?;
+ let mut manager = build_plugin_manager(&cwd, &loader, &runtime_config);
+ let result = handle_plugins_slash_command(action, target, &mut manager)?;
+ match output_format {
+ CliOutputFormat::Text => println!("{}", result.message),
+ CliOutputFormat::Json => println!(
+ "{}",
+ serde_json::to_string_pretty(&json!({
+ "kind": "plugin",
+ "action": action.unwrap_or("list"),
+ "target": target,
+ "message": result.message,
+ "reload_runtime": result.reload_runtime,
+ }))?
+ ),
+ }
+ Ok(())
+ }
+
fn print_diff() -> Result<(), Box<dyn std::error::Error>> {
println!("{}", render_diff_report()?);
Ok(())
@@ -7449,6 +7504,13 @@ mod tests {
output_format: CliOutputFormat::Text,
}
);
+ assert_eq!(
+ parse_args(&["/skill".to_string()]).expect("/skill should parse"),
+ CliAction::Skills {
+ args: None,
+ output_format: CliOutputFormat::Text,
+ }
+ );
assert_eq!(
parse_args(&["/skills".to_string(), "help".to_string()])
.expect("/skills help should parse"),
@@ -7457,6 +7519,14 @@ mod tests {
output_format: CliOutputFormat::Text,
}
);
+ assert_eq!(
+ parse_args(&["/skill".to_string(), "list".to_string()])
+ .expect("/skill list should parse"),
+ CliAction::Skills {
+ args: Some("list".to_string()),
+ output_format: CliOutputFormat::Text,
+ }
+ );
assert_eq!(
parse_args(&[
"/skills".to_string(),
@@ -7515,6 +7585,16 @@ mod tests {
assert!(report.contains("Use /help"));
}
+ #[test]
+ fn formats_namespaced_omc_slash_command_with_contract_guidance() {
+ let report = format_unknown_slash_command_message("oh-my-claudecode:hud");
+ assert!(report.contains("unknown slash command: /oh-my-claudecode:hud"));
+ assert!(report.contains("Claude Code/OMC plugin command"));
+ assert!(report.contains("plugin slash commands"));
+ assert!(report.contains("statusline"));
+ assert!(report.contains("session hooks"));
+ }
+
#[test]
fn parses_resume_flag_with_slash_command() {
let args = vec![
@@ -8312,6 +8392,14 @@ UU conflicted.rs",
assert!(message.contains("/help"));
}
+ #[test]
+ fn unknown_omc_slash_command_guidance_explains_runtime_gap() {
+ let message = format_unknown_slash_command("oh-my-claudecode:hud");
+ assert!(message.contains("Unknown slash command: /oh-my-claudecode:hud"));
+ assert!(message.contains("Claude Code/OMC plugin command"));
+ assert!(message.contains("does not yet load plugin slash commands"));
+ }
+
#[test]
fn resume_usage_mentions_latest_shortcut() {
let usage = render_resume_usage();
diff --git a/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs b/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs
index 8988291b..21a93e27 100644
--- a/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs
+++ b/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs
@@ -104,6 +104,31 @@ fn slash_command_names_match_known_commands_and_suggest_nearby_unknown_ones() {
fs::remove_dir_all(temp_dir).expect("cleanup temp dir");
}
+#[test]
+fn omc_namespaced_slash_commands_surface_a_targeted_compatibility_hint() {
+ let temp_dir = unique_temp_dir("slash-dispatch-omc");
+ fs::create_dir_all(&temp_dir).expect("temp dir should exist");
+
+ let output = Command::new(env!("CARGO_BIN_EXE_claw"))
+ .current_dir(&temp_dir)
+ .arg("/oh-my-claudecode:hud")
+ .output()
+ .expect("claw should launch");
+
+ assert!(
+ !output.status.success(),
+ "stdout:\n{}\n\nstderr:\n{}",
+ String::from_utf8_lossy(&output.stdout),
+ String::from_utf8_lossy(&output.stderr)
+ );
+ let stderr = String::from_utf8(output.stderr).expect("stderr should be utf8");
+ assert!(stderr.contains("unknown slash command outside the REPL: /oh-my-claudecode:hud"));
+ assert!(stderr.contains("Claude Code/OMC plugin command"));
+ assert!(stderr.contains("does not yet load plugin slash commands"));
+
+ fs::remove_dir_all(temp_dir).expect("cleanup temp dir");
+}
+
#[test]
fn config_command_loads_defaults_from_standard_config_locations() {
// given
diff --git a/rust/crates/tools/src/lib.rs b/rust/crates/tools/src/lib.rs
index ac24fde4..d80e9956 100644
--- a/rust/crates/tools/src/lib.rs
+++ b/rust/crates/tools/src/lib.rs
@@ -2977,6 +2977,244 @@ fn resolve_skill_path(skill: &str) -> Result<std::path::PathBuf, String> {
commands::resolve_skill_path(&cwd, skill).map_err(|error| error.to_string())
}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SkillLookupOrigin {
+ SkillsDir,
+ LegacyCommandsDir,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SkillLookupRoot {
+ path: std::path::PathBuf,
+ origin: SkillLookupOrigin,
+}
+
+fn skill_lookup_roots() -> Vec<SkillLookupRoot> {
+ let mut roots = Vec::new();
+
+ if let Ok(cwd) = std::env::current_dir() {
+ push_project_skill_lookup_roots(&mut roots, &cwd);
+ }
+
+ if let Ok(claw_config_home) = std::env::var("CLAW_CONFIG_HOME") {
+ push_prefixed_skill_lookup_roots(&mut roots, std::path::Path::new(&claw_config_home));
+ }
+ if let Ok(codex_home) = std::env::var("CODEX_HOME") {
+ push_prefixed_skill_lookup_roots(&mut roots, std::path::Path::new(&codex_home));
+ }
+ if let Ok(home) = std::env::var("HOME") {
+ push_home_skill_lookup_roots(&mut roots, std::path::Path::new(&home));
+ }
+ if let Ok(claude_config_dir) = std::env::var("CLAUDE_CONFIG_DIR") {
+ let claude_config_dir = std::path::PathBuf::from(claude_config_dir);
+ push_skill_lookup_root(
+ &mut roots,
+ claude_config_dir.join("skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ &mut roots,
+ claude_config_dir.join("skills").join("omc-learned"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ &mut roots,
+ claude_config_dir.join("commands"),
+ SkillLookupOrigin::LegacyCommandsDir,
+ );
+ }
+ push_skill_lookup_root(
+ &mut roots,
+ std::path::PathBuf::from("/home/bellman/.claw/skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ &mut roots,
+ std::path::PathBuf::from("/home/bellman/.codex/skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+
+ roots
+}
+
+fn push_project_skill_lookup_roots(roots: &mut Vec<SkillLookupRoot>, cwd: &std::path::Path) {
+ for ancestor in cwd.ancestors() {
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".omc"));
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".agents"));
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".claw"));
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".codex"));
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".claude"));
+ }
+}
+
+fn push_home_skill_lookup_roots(roots: &mut Vec<SkillLookupRoot>, home: &std::path::Path) {
+ push_prefixed_skill_lookup_roots(roots, &home.join(".omc"));
+ push_prefixed_skill_lookup_roots(roots, &home.join(".claw"));
+ push_prefixed_skill_lookup_roots(roots, &home.join(".codex"));
+ push_prefixed_skill_lookup_roots(roots, &home.join(".claude"));
+ push_skill_lookup_root(
+ roots,
+ home.join(".agents").join("skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ roots,
+ home.join(".config").join("opencode").join("skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ roots,
+ home.join(".claude").join("skills").join("omc-learned"),
+ SkillLookupOrigin::SkillsDir,
+ );
+}
+
+fn push_prefixed_skill_lookup_roots(roots: &mut Vec<SkillLookupRoot>, prefix: &std::path::Path) {
+ push_skill_lookup_root(roots, prefix.join("skills"), SkillLookupOrigin::SkillsDir);
+ push_skill_lookup_root(
+ roots,
+ prefix.join("commands"),
+ SkillLookupOrigin::LegacyCommandsDir,
+ );
+}
+
+fn push_skill_lookup_root(
+ roots: &mut Vec<SkillLookupRoot>,
+ path: std::path::PathBuf,
+ origin: SkillLookupOrigin,
+) {
+ if path.is_dir() && !roots.iter().any(|existing| existing.path == path) {
+ roots.push(SkillLookupRoot { path, origin });
+ }
+}
+
+fn resolve_skill_path_in_root(
+ root: &SkillLookupRoot,
+ requested: &str,
+) -> Option<std::path::PathBuf> {
+ match root.origin {
+ SkillLookupOrigin::SkillsDir => resolve_skill_path_in_skills_dir(&root.path, requested),
+ SkillLookupOrigin::LegacyCommandsDir => {
+ resolve_skill_path_in_legacy_commands_dir(&root.path, requested)
+ }
+ }
+}
+
+fn resolve_skill_path_in_skills_dir(
+ root: &std::path::Path,
+ requested: &str,
+) -> Option<std::path::PathBuf> {
+ let direct = root.join(requested).join("SKILL.md");
+ if direct.is_file() {
+ return Some(direct);
+ }
+
+ let entries = std::fs::read_dir(root).ok()?;
+ for entry in entries.flatten() {
+ if !entry.path().is_dir() {
+ continue;
+ }
+ let skill_path = entry.path().join("SKILL.md");
+ if !skill_path.is_file() {
+ continue;
+ }
+ if entry
+ .file_name()
+ .to_string_lossy()
+ .eq_ignore_ascii_case(requested)
+ || skill_frontmatter_name_matches(&skill_path, requested)
+ {
+ return Some(skill_path);
+ }
+ }
+
+ None
+}
+
+fn resolve_skill_path_in_legacy_commands_dir(
+ root: &std::path::Path,
+ requested: &str,
+) -> Option<std::path::PathBuf> {
+ let direct_dir = root.join(requested).join("SKILL.md");
+ if direct_dir.is_file() {
+ return Some(direct_dir);
+ }
+
+ let direct_markdown = root.join(format!("{requested}.md"));
+ if direct_markdown.is_file() {
+ return Some(direct_markdown);
+ }
+
+ let entries = std::fs::read_dir(root).ok()?;
+ for entry in entries.flatten() {
+ let path = entry.path();
+ let candidate_path = if path.is_dir() {
+ let skill_path = path.join("SKILL.md");
+ if !skill_path.is_file() {
+ continue;
+ }
+ skill_path
+ } else if path
+ .extension()
+ .is_some_and(|ext| ext.to_string_lossy().eq_ignore_ascii_case("md"))
+ {
+ path
+ } else {
+ continue;
+ };
+
+ let matches_entry_name = candidate_path
+ .file_stem()
+ .is_some_and(|stem| stem.to_string_lossy().eq_ignore_ascii_case(requested))
+ || entry
+ .file_name()
+ .to_string_lossy()
+ .trim_end_matches(".md")
+ .eq_ignore_ascii_case(requested);
+ if matches_entry_name || skill_frontmatter_name_matches(&candidate_path, requested) {
+ return Some(candidate_path);
+ }
+ }
+
+ None
+}
+
+fn skill_frontmatter_name_matches(path: &std::path::Path, requested: &str) -> bool {
+ std::fs::read_to_string(path)
+ .ok()
+ .and_then(|contents| parse_skill_name(&contents))
+ .is_some_and(|name| name.eq_ignore_ascii_case(requested))
+}
+
+fn parse_skill_name(contents: &str) -> Option<String> {
+ parse_skill_frontmatter_value(contents, "name")
+}
+
+fn parse_skill_frontmatter_value(contents: &str, key: &str) -> Option<String> {
+ let mut lines = contents.lines();
+ if lines.next().map(str::trim) != Some("---") {
+ return None;
+ }
+
+ for line in lines {
+ let trimmed = line.trim();
+ if trimmed == "---" {
+ break;
+ }
+ if let Some(value) = trimmed.strip_prefix(&format!("{key}:")) {
+ let value = value
+ .trim()
+ .trim_matches(|ch| matches!(ch, '"' | '\''))
+ .trim();
+ if !value.is_empty() {
+ return Some(value.to_string());
+ }
+ }
+ }
+
+ None
+}
+
const DEFAULT_AGENT_MODEL: &str = "claude-opus-4-6";
const DEFAULT_AGENT_SYSTEM_DATE: &str = "2026-03-31";
const DEFAULT_AGENT_MAX_ITERATIONS: usize = 32;
@@ -5796,6 +6034,305 @@ mod tests {
fs::remove_dir_all(root).expect("temp project should clean up");
}
+ #[test]
+ fn skill_loads_project_local_claude_skill_prompt() {
+ let _guard = env_lock().lock().expect("env lock should acquire");
+ let root = temp_path("project-skills");
+ let home = root.join("home");
+ let workspace = root.join("workspace");
+ let nested = workspace.join("nested");
+ let skill_dir = workspace.join(".claude").join("skills").join("trace");
+ fs::create_dir_all(&skill_dir).expect("skill dir should exist");
+ fs::create_dir_all(&nested).expect("nested cwd should exist");
+ fs::write(
+ skill_dir.join("SKILL.md"),
+ "---\nname: trace\ndescription: Project-local trace helper\n---\n# trace\n",
+ )
+ .expect("skill file should exist");
+
+ let original_home = std::env::var("HOME").ok();
+ let original_config_home = std::env::var("CLAW_CONFIG_HOME").ok();
+ let original_codex_home = std::env::var("CODEX_HOME").ok();
+ let original_dir = std::env::current_dir().expect("cwd");
+ std::env::set_var("HOME", &home);
+ std::env::remove_var("CLAW_CONFIG_HOME");
+ std::env::remove_var("CODEX_HOME");
+ std::env::set_current_dir(&nested).expect("set cwd");
+
+ let result = execute_tool("Skill", &json!({ "skill": "trace" }))
+ .expect("project-local skill should resolve");
+
+ let output: serde_json::Value = serde_json::from_str(&result).expect("valid json");
+ assert!(output["path"]
+ .as_str()
+ .expect("path")
+ .ends_with(".claude/skills/trace/SKILL.md"));
+ assert_eq!(output["description"], "Project-local trace helper");
+
+ std::env::set_current_dir(&original_dir).expect("restore cwd");
+ match original_home {
+ Some(value) => std::env::set_var("HOME", value),
+ None => std::env::remove_var("HOME"),
+ }
+ match original_config_home {
+ Some(value) => std::env::set_var("CLAW_CONFIG_HOME", value),
+ None => std::env::remove_var("CLAW_CONFIG_HOME"),
+ }
+ match original_codex_home {
+ Some(value) => std::env::set_var("CODEX_HOME", value),
+ None => std::env::remove_var("CODEX_HOME"),
+ }
+ fs::remove_dir_all(root).expect("temp tree should clean up");
+ }
+
+ #[test]
+ fn skill_loads_project_local_omc_and_agents_skill_prompts() {
+ let _guard = env_lock().lock().expect("env lock should acquire");
+ let root = temp_path("project-omc-skills");
+ let home = root.join("home");
+ let workspace = root.join("workspace");
+ let nested = workspace.join("nested");
+ let omc_skill_dir = workspace.join(".omc").join("skills").join("hud");
+ let agents_skill_dir = workspace.join(".agents").join("skills").join("trace");
+ fs::create_dir_all(&omc_skill_dir).expect("omc skill dir should exist");
+ fs::create_dir_all(&agents_skill_dir).expect("agents skill dir should exist");
+ fs::create_dir_all(&nested).expect("nested cwd should exist");
+ fs::write(
+ omc_skill_dir.join("SKILL.md"),
+ "---\nname: hud\ndescription: Project-local OMC HUD helper\n---\n# hud\n",
+ )
+ .expect("omc skill file should exist");
+ fs::write(
+ agents_skill_dir.join("SKILL.md"),
+ "---\nname: trace\ndescription: Project-local agents compatibility helper\n---\n# trace\n",
+ )
+ .expect("agents skill file should exist");
+
+ let original_home = std::env::var("HOME").ok();
+ let original_config_home = std::env::var("CLAW_CONFIG_HOME").ok();
+ let original_codex_home = std::env::var("CODEX_HOME").ok();
+ let original_dir = std::env::current_dir().expect("cwd");
+ std::env::set_var("HOME", &home);
+ std::env::remove_var("CLAW_CONFIG_HOME");
+ std::env::remove_var("CODEX_HOME");
+ std::env::set_current_dir(&nested).expect("set cwd");
+
+ let omc_result =
+ execute_tool("Skill", &json!({ "skill": "hud" })).expect("omc skill should resolve");
+ let agents_result = execute_tool("Skill", &json!({ "skill": "trace" }))
+ .expect("agents skill should resolve");
+
+ let omc_output: serde_json::Value = serde_json::from_str(&omc_result).expect("valid json");
+ let agents_output: serde_json::Value =
+ serde_json::from_str(&agents_result).expect("valid json");
+ assert!(omc_output["path"]
+ .as_str()
+ .expect("path")
+ .ends_with(".omc/skills/hud/SKILL.md"));
+ assert_eq!(omc_output["description"], "Project-local OMC HUD helper");
+ assert!(agents_output["path"]
+ .as_str()
+ .expect("path")
+ .ends_with(".agents/skills/trace/SKILL.md"));
+ assert_eq!(
+ agents_output["description"],
+ "Project-local agents compatibility helper"
+ );
+
+ std::env::set_current_dir(&original_dir).expect("restore cwd");
+ match original_home {
+ Some(value) => std::env::set_var("HOME", value),
+ None => std::env::remove_var("HOME"),
+ }
+ match original_config_home {
+ Some(value) => std::env::set_var("CLAW_CONFIG_HOME", value),
+ None => std::env::remove_var("CLAW_CONFIG_HOME"),
+ }
+ match original_codex_home {
+ Some(value) => std::env::set_var("CODEX_HOME", value),
+ None => std::env::remove_var("CODEX_HOME"),
+ }
+ fs::remove_dir_all(root).expect("temp tree should clean up");
+ }
+
+ #[test]
+ fn skill_loads_learned_skill_from_claude_config_dir() {
+ let _guard = env_lock().lock().expect("env lock should acquire");
+ let root = temp_path("claude-config-learned-skill");
+ let home = root.join("home");
+ let claude_config_dir = root.join("claude-config");
+ let learned_skill_dir = claude_config_dir
+ .join("skills")
+ .join("omc-learned")
+ .join("learned");
+ fs::create_dir_all(&learned_skill_dir).expect("learned skill dir should exist");
+ fs::write(
+ learned_skill_dir.join("SKILL.md"),
+ "---\nname: learned\ndescription: Learned OMC skill\n---\n# learned\n",
+ )
+ .expect("learned skill file should exist");
+
+ let original_home = std::env::var("HOME").ok();
+ let original_config_home = std::env::var("CLAW_CONFIG_HOME").ok();
+ let original_codex_home = std::env::var("CODEX_HOME").ok();
+ let original_claude_config_dir = std::env::var("CLAUDE_CONFIG_DIR").ok();
+ std::env::set_var("HOME", &home);
+ std::env::remove_var("CLAW_CONFIG_HOME");
+ std::env::remove_var("CODEX_HOME");
+ std::env::set_var("CLAUDE_CONFIG_DIR", &claude_config_dir);
+
+ let result = execute_tool("Skill", &json!({ "skill": "learned" }))
+ .expect("learned skill should resolve");
+
+ let output: serde_json::Value = serde_json::from_str(&result).expect("valid json");
+ assert!(output["path"]
+ .as_str()
+ .expect("path")
+ .ends_with("skills/omc-learned/learned/SKILL.md"));
+ assert_eq!(output["description"], "Learned OMC skill");
+
+ match original_home {
+ Some(value) => std::env::set_var("HOME", value),
+ None => std::env::remove_var("HOME"),
+ }
+ match original_config_home {
+ Some(value) => std::env::set_var("CLAW_CONFIG_HOME", value),
+ None => std::env::remove_var("CLAW_CONFIG_HOME"),
+ }
+ match original_codex_home {
+ Some(value) => std::env::set_var("CODEX_HOME", value),
+ None => std::env::remove_var("CODEX_HOME"),
+ }
+ match original_claude_config_dir {
+ Some(value) => std::env::set_var("CLAUDE_CONFIG_DIR", value),
+ None => std::env::remove_var("CLAUDE_CONFIG_DIR"),
+ }
+ fs::remove_dir_all(root).expect("temp tree should clean up");
+ }
+
+ #[test]
+ fn skill_loads_direct_skill_and_legacy_command_from_claude_config_dir() {
+ let _guard = env_lock().lock().expect("env lock should acquire");
+ let root = temp_path("claude-config-direct-skill");
+ let home = root.join("home");
+ let claude_config_dir = root.join("claude-config");
+ let skill_dir = claude_config_dir.join("skills").join("statusline");
+ let command_dir = claude_config_dir.join("commands");
+ fs::create_dir_all(&skill_dir).expect("direct skill dir should exist");
+ fs::create_dir_all(&command_dir).expect("command dir should exist");
+ fs::write(
+ skill_dir.join("SKILL.md"),
+ "---\nname: statusline\ndescription: Claude config skill\n---\n# statusline\n",
+ )
+ .expect("direct skill file should exist");
+ fs::write(
+ command_dir.join("doctor-check.md"),
+ "---\nname: doctor-check\ndescription: Claude config command\n---\n# doctor-check\n",
+ )
+ .expect("direct command file should exist");
+
+ let original_home = std::env::var("HOME").ok();
+ let original_config_home = std::env::var("CLAW_CONFIG_HOME").ok();
+ let original_codex_home = std::env::var("CODEX_HOME").ok();
+ let original_claude_config_dir = std::env::var("CLAUDE_CONFIG_DIR").ok();
+ std::env::set_var("HOME", &home);
+ std::env::remove_var("CLAW_CONFIG_HOME");
+ std::env::remove_var("CODEX_HOME");
+ std::env::set_var("CLAUDE_CONFIG_DIR", &claude_config_dir);
+
+ let direct_skill =
+ execute_tool("Skill", &json!({ "skill": "statusline" })).expect("direct skill");
+ let direct_skill_output: serde_json::Value =
+ serde_json::from_str(&direct_skill).expect("valid skill json");
+ assert!(direct_skill_output["path"]
+ .as_str()
+ .expect("path")
+ .ends_with("skills/statusline/SKILL.md"));
+ assert_eq!(direct_skill_output["description"], "Claude config skill");
+
+ let legacy_command =
+ execute_tool("Skill", &json!({ "skill": "doctor-check" })).expect("direct command");
+ let legacy_command_output: serde_json::Value =
+ serde_json::from_str(&legacy_command).expect("valid command json");
+ assert!(legacy_command_output["path"]
+ .as_str()
+ .expect("path")
+ .ends_with("commands/doctor-check.md"));
+ assert_eq!(
+ legacy_command_output["description"],
+ "Claude config command"
+ );
+
+ match original_home {
+ Some(value) => std::env::set_var("HOME", value),
+ None => std::env::remove_var("HOME"),
+ }
+ match original_config_home {
+ Some(value) => std::env::set_var("CLAW_CONFIG_HOME", value),
+ None => std::env::remove_var("CLAW_CONFIG_HOME"),
+ }
+ match original_codex_home {
+ Some(value) => std::env::set_var("CODEX_HOME", value),
+ None => std::env::remove_var("CODEX_HOME"),
+ }
+ match original_claude_config_dir {
+ Some(value) => std::env::set_var("CLAUDE_CONFIG_DIR", value),
+ None => std::env::remove_var("CLAUDE_CONFIG_DIR"),
+ }
+ fs::remove_dir_all(root).expect("temp tree should clean up");
+ }
+
+ #[test]
+ fn skill_loads_project_local_legacy_command_markdown() {
+ let _guard = env_lock().lock().expect("env lock should acquire");
+ let root = temp_path("project-legacy-command");
+ let home = root.join("home");
+ let workspace = root.join("workspace");
+ let nested = workspace.join("nested");
+ let command_dir = workspace.join(".claude").join("commands");
+ fs::create_dir_all(&command_dir).expect("legacy command dir should exist");
+ fs::create_dir_all(&nested).expect("nested cwd should exist");
+ fs::write(
+ command_dir.join("team.md"),
+ "---\nname: team\ndescription: Legacy team workflow\n---\n# team\n",
+ )
+ .expect("legacy command file should exist");
+
+ let original_home = std::env::var("HOME").ok();
+ let original_config_home = std::env::var("CLAW_CONFIG_HOME").ok();
+ let original_codex_home = std::env::var("CODEX_HOME").ok();
+ let original_dir = std::env::current_dir().expect("cwd");
+ std::env::set_var("HOME", &home);
+ std::env::remove_var("CLAW_CONFIG_HOME");
+ std::env::remove_var("CODEX_HOME");
+ std::env::set_current_dir(&nested).expect("set cwd");
+
+ let result = execute_tool("Skill", &json!({ "skill": "team" }))
+ .expect("legacy command markdown should resolve");
+
+ let output: serde_json::Value = serde_json::from_str(&result).expect("valid json");
+ assert!(output["path"]
+ .as_str()
+ .expect("path")
+ .ends_with(".claude/commands/team.md"));
+ assert_eq!(output["description"], "Legacy team workflow");
+
+ std::env::set_current_dir(&original_dir).expect("restore cwd");
+ match original_home {
+ Some(value) => std::env::set_var("HOME", value),
+ None => std::env::remove_var("HOME"),
+ }
+ match original_config_home {
+ Some(value) => std::env::set_var("CLAW_CONFIG_HOME", value),
+ None => std::env::remove_var("CLAW_CONFIG_HOME"),
+ }
+ match original_codex_home {
+ Some(value) => std::env::set_var("CODEX_HOME", value),
+ None => std::env::remove_var("CODEX_HOME"),
+ }
+ fs::remove_dir_all(root).expect("temp tree should clean up");
+ }
+
#[test]
fn tool_search_supports_keyword_and_select_queries() {
let keyword = execute_tool(