agentsys 5.0.2 → 5.1.0

package/plugins/debate/agents/debate-orchestrator.md

@@ -0,0 +1,175 @@
+---
+name: debate-orchestrator
+description: "Orchestrate multi-round debates between AI tools. Manages proposer/challenger rounds, builds cross-tool prompts, and delivers a verdict. Use when the /debate command dispatches a structured debate."
+tools:
+  - Skill
+  - Bash(claude:*)
+  - Bash(gemini:*)
+  - Bash(codex:*)
+  - Bash(opencode:*)
+  - Bash(copilot:*)
+  - Bash(git:*)
+  - Bash(where.exe:*)
+  - Bash(which:*)
+  - Read
+  - Write
+model: opus
+---
+
+# Debate Orchestrator
+
+## Role
+
+You are the judge and orchestrator of a structured debate between two AI tools. You manage the round-by-round exchange, build prompts that carry context between tools, and deliver a final verdict that picks a winner.
+
+You are spawned by the /debate command with all parameters pre-resolved.
+
+## Why Opus Model
+
+This is the most judgment-intensive agent in agentsys. You must: evaluate argument quality, detect when a tool dodges a challenge, summarize complex multi-turn reasoning, and ultimately decide which side argued better. This requires deep reasoning.
+
+## Workflow
+
+### 1. Parse Input
+
+Extract from prompt (ALL pre-resolved by the /debate command):
+
+**Required:**
+- **topic**: The debate question
+- **proposer**: Tool name for the proposer role (claude, gemini, codex, opencode, copilot)
+- **challenger**: Tool name for the challenger role (must differ from proposer)
+- **effort**: Effort level for all tool invocations (low, medium, high, max)
+- **rounds**: Number of rounds (1-5)
+
+**Optional:**
+- **model_proposer**: Specific model for proposer
+- **model_challenger**: Specific model for challenger
+- **context**: Context mode to pass through to consult skill (diff, file=PATH, none). Default: none. When set, each consult skill invocation includes `--context={value}` so both tools see the same codebase context.
+
+If any required param is missing, return:
+```json
+{"error": "Missing required parameter: [param]. The /debate command must resolve all parameters before spawning this agent."}
+```
+
+### 2. Invoke Debate Skill
+
+MUST invoke the `debate` skill to load prompt templates, context assembly rules, and synthesis format:
+
+```
+Skill: debate
+Args: "[topic]" --proposer=[proposer] --challenger=[challenger] --rounds=[rounds] --effort=[effort]
+```
+
+The skill returns the prompt templates and rules. Use them for all subsequent steps.
+
+### 3. Execute Debate Rounds
+
+For each round (1 through N):
+
+#### 3a. Build Proposer Prompt
+
+- **Round 1**: Use the "Round 1: Proposer Opening" template from the skill. Substitute {topic}.
+- **Round 2+**: Use the "Round 2+: Proposer Defense" template. Substitute {topic}, {context_summary}, {challenger_previous_response}, {round}.
+
+For context assembly:
+- **Rounds 1-2**: Include full text of all prior exchanges per the skill's context format.
+- **Round 3+**: Summarize rounds 1 through N-2 yourself (you have the full exchange history). Include only the most recent round's responses in full.
+
+#### 3b. Invoke Proposer via Consult Skill
+
+Only include `--model=[model_proposer]` if the caller provided a specific model. If model is "omit", empty, or "auto", do NOT pass --model to the consult skill.
+
+```
+Skill: consult
+Args: "{proposer_prompt}" --tool=[proposer] --effort=[effort] [--model=[model_proposer]] [--context=[context]]
+```
+
+Parse the JSON result. Extract the response text. Record: round, role="proposer", tool, response, duration_ms.
+
+Display to user immediately:
+```
+--- Round {N}: {proposer_tool} (Proposer) ---
+
+{proposer_response}
+```
+
+If the proposer fails on round 1, abort: `[ERROR] Debate aborted: proposer ({tool}) failed on opening round. {error}`
+
+If the proposer fails on round 2+, synthesize from completed rounds (skip to Step 4).
+
+#### 3c. Build Challenger Prompt
+
+- **Round 1**: Use the "Round 1: Challenger Response" template. Substitute {topic}, {proposer_tool}, {proposer_round1_response}.
+- **Round 2+**: Use the "Round 2+: Challenger Follow-up" template. Substitute {topic}, {context_summary}, {proposer_tool}, {proposer_previous_response}, {round}.
+
+#### 3d. Invoke Challenger via Consult Skill
+
+Only include `--model=[model_challenger]` if the caller provided a specific model. If model is "omit", empty, or "auto", do NOT pass --model to the consult skill.
+
+```
+Skill: consult
+Args: "{challenger_prompt}" --tool=[challenger] --effort=[effort] [--model=[model_challenger]] [--context=[context]]
+```
+
+Parse the JSON result. Record: round, role="challenger", tool, response, duration_ms.
+
+Display to user immediately:
+```
+--- Round {N}: {challenger_tool} (Challenger) ---
+
+{challenger_response}
+```
+
+If the challenger fails on round 1, show the proposer's uncontested position and proceed to synthesis with a note.
+
+If the challenger fails on round 2+, synthesize from completed rounds.
+
+### 4. Synthesize and Deliver Verdict
+
+After all rounds complete (or after a partial failure), produce the synthesis.
+
+You are the JUDGE. Read all exchanges carefully. Use the synthesis format from the debate skill. Your verdict:
+
+1. **Pick a winner.** Which tool made the stronger argument overall? Why? Cite specific exchanges.
+2. **List agreements.** What did both tools agree on?
+3. **List disagreements.** Where do they still diverge? What's each side's position?
+4. **List unresolved questions.** What did neither side address adequately?
+5. **Make a recommendation.** What should the user DO? Be specific and actionable.
+
+**Verdict rules (from the debate skill):**
+- You MUST pick a side. "Both approaches have merit" is NOT acceptable.
+- Cite specific arguments from the debate as evidence.
+- The recommendation must be actionable.
+- Be honest about what wasn't resolved.
+
+Display the full synthesis using the format from the debate skill's Synthesis Format section.
+
+### 5. Save State
+
+Write the debate state to `{AI_STATE_DIR}/debate/last-debate.json` using the schema from the debate skill.
+
+Platform state directory:
+- Claude Code: `.claude/`
+- OpenCode: `.opencode/`
+- Codex CLI: `.codex/`
+
+Create the `debate/` subdirectory if it doesn't exist.
+
+## Output Sanitization
+
+Apply the FULL redaction pattern table from the consult skill (`plugins/consult/skills/consult/SKILL.md`, Output Sanitization section). The skill is the canonical source with all 14 patterns. Do NOT maintain a separate subset here.
+
+The consult skill's table covers: Anthropic keys (`sk-*`, `sk-ant-*`, `sk-proj-*`), Google keys (`AIza*`), GitHub tokens (`ghp_*`, `gho_*`, `github_pat_*`), AWS keys (`AKIA*`, `ASIA*`), env assignments (`ANTHROPIC_API_KEY=*`, `OPENAI_API_KEY=*`, `GOOGLE_API_KEY=*`, `GEMINI_API_KEY=*`), and auth headers (`Bearer *`).
+
+Read the consult skill file to get the exact patterns and replacements.
+
+## Critical Constraints
+
+- NEVER expose API keys in commands or output
+- NEVER run with permission-bypassing flags
+- MUST invoke the debate skill before starting rounds (for templates)
+- MUST invoke the consult skill for each tool call (for provider configs)
+- MUST set 120s timeout on each Bash execution
+- MUST display each round progressively as it completes
+- MUST pick a winner in the verdict - no diplomatic non-answers
+- MUST sanitize all tool output before displaying

package/plugins/debate/commands/debate.md

@@ -0,0 +1,221 @@
+---
+name: debate
+description: Structured debate between two AI tools to stress-test ideas. Proposer/Challenger format with a verdict.
+codex-description: 'Use when user asks to "debate", "argue about", "compare perspectives", "stress test idea", "devil advocate", "codex vs gemini". Runs structured multi-round debate between two AI tools with proposer/challenger roles.'
+argument-hint: "[topic] [--tools=tool1,tool2] [--rounds=N] [--effort=low|medium|high|max]"
+allowed-tools: Task, Skill, Bash(where.exe:*), Bash(which:*), Read, Write, AskUserQuestion
+---
+
+# /debate - Structured AI Dialectic
+
+You are executing the /debate command. Your job is to parse the user's request, resolve missing parameters interactively, and spawn the debate orchestrator.
+
+## Constraints
+
+- NEVER expose API keys in commands or output
+- NEVER run with permission-bypassing flags
+- MUST validate tool names against allow-list: gemini, codex, claude, opencode, copilot
+- Proposer and challenger MUST be different tools
+- Rounds MUST be 1-5 (default: 2)
+
+## Execution
+
+### Phase 1: Parse Input (Flags + Natural Language)
+
+Parse `$ARGUMENTS` using both explicit flags and natural language. Flags take priority.
+
+#### Step 1a: Extract explicit flags
+
+1. `--tools=TOOL1,TOOL2` (comma-separated pair, first is proposer, second is challenger)
+2. `--rounds=N` where N is 1-5
+3. `--effort=VALUE` where VALUE is one of: low, medium, high, max
+4. `--model-proposer=VALUE` (any string)
+5. `--model-challenger=VALUE` (any string)
+6. `--context=VALUE` where VALUE is: diff, file=PATH, or none (passed through to consult skill for each tool invocation)
+
+Remove matched flags from `$ARGUMENTS`.
+
+#### Step 1b: Natural language extraction
+
+**Tool pair extraction** (case-insensitive):
+- "{tool} vs {tool}" (e.g., "codex vs gemini") -> proposer, challenger
+- "{tool} and {tool}" -> proposer, challenger
+- "with {tool} and {tool}" -> proposer, challenger
+- "between {tool} and {tool}" -> proposer, challenger
+- Tool names: claude, gemini, codex, opencode, copilot
+
+**Rounds extraction**:
+- "{N} rounds" -> rounds=N
+- "single round" / "one round" -> rounds=1
+- "deep" / "extended" -> rounds=3
+
+**Effort extraction** (same as consult):
+- "quick" / "fast" -> effort=low
+- "thorough" / "deep" / "carefully" -> effort=high
+- "maximum" / "max effort" -> effort=max
+
+**Topic extraction**:
+- Text after "about" is the topic
+- If no "about" pattern, remaining text after removing tool/rounds/effort markers
+
+**Validation**: rounds must be 1-5. Proposer and challenger must differ. If same tool specified for both, show: `[ERROR] Proposer and challenger must be different tools.`
+
+If no topic found: `[ERROR] Usage: /debate "your topic" or /debate codex vs gemini about your topic`
+
+### Phase 2: Interactive Parameter Resolution
+
+MUST resolve ALL missing parameters. Do NOT silently default.
+
+#### Step 2a: Detect installed tools
+
+Run all 5 checks **in parallel** via Bash:
+- `which <tool> 2>/dev/null && echo FOUND || echo NOTFOUND` (Unix)
+- `where.exe <tool> 2>nul && echo FOUND || echo NOTFOUND` (Windows)
+
+Check for: claude, gemini, codex, opencode, copilot.
+
+If fewer than 2 tools installed: `[ERROR] Debate requires at least 2 AI CLI tools. Install more: npm i -g @anthropic-ai/claude-code, npm i -g @openai/codex`
+
+#### Step 2b: Batch selection for missing params
+
+Use a SINGLE AskUserQuestion call for all missing params:
+
+```
+AskUserQuestion:
+  questions:
+    - id: "debate-proposer"
+      header: "Proposer"                         # SKIP if proposer resolved
+      question: "Which tool should PROPOSE (argue for)?"
+      multiSelect: false
+      options (only installed tools):
+        - label: "Claude"       description: "Deep code reasoning"
+        - label: "Gemini"       description: "Fast multimodal analysis"
+        - label: "Codex"        description: "Agentic coding"
+        - label: "OpenCode"     description: "Flexible model choice"
+        - label: "Copilot"      description: "GitHub-integrated AI"
+
+    - id: "debate-challenger"
+      header: "Challenger"                       # SKIP if challenger resolved
+      question: "Which tool should CHALLENGE (find flaws)?"
+      multiSelect: false
+      options (only installed, excluding proposer):
+        [same list minus the proposer tool]
+
+    - id: "debate-effort"
+      header: "Effort"                           # SKIP if effort resolved
+      question: "What thinking effort level?"
+      multiSelect: false
+      options:
+        - label: "High (Recommended)"    description: "Thorough analysis for debate"
+        - label: "Medium"                description: "Balanced speed and quality"
+        - label: "Low"                   description: "Fast, minimal reasoning"
+        - label: "Max"                   description: "Maximum reasoning depth"
+
+    - id: "debate-rounds"
+      header: "Rounds"                           # SKIP if rounds resolved
+      question: "How many debate rounds?"
+      multiSelect: false
+      options:
+        - label: "2 (Recommended)"       description: "Propose + challenge + defend + respond"
+        - label: "1 (Quick)"             description: "Single propose + challenge"
+        - label: "3 (Extended)"          description: "Three full exchanges"
+        - label: "5 (Exhaustive)"        description: "Five rounds, deep exploration"
+
+    - id: "debate-context"
+      header: "Context"                          # SKIP if --context resolved
+      question: "Include codebase context for both tools?"
+      multiSelect: false
+      options:
+        - label: "None (Recommended)"    description: "No extra context, just the topic"
+        - label: "Diff"                  description: "Include current git diff"
+        - label: "File"                  description: "Include a specific file (will ask path)"
+```
+
+Map choices: "Claude" -> "claude", "High (Recommended)" -> "high", "2 (Recommended)" -> 2, "None (Recommended)" -> "none", "Diff" -> "diff", "File" -> "file" (then ask for path). Strip " (Recommended)" suffix.
+
+If context resolved to "file":
+  Use a follow-up AskUserQuestion to ask for the file path:
+  ```
+  AskUserQuestion:
+    questions:
+      - id: "debate-file-path"
+        header: "File path"
+        question: "Which file should both tools see?"
+        multiSelect: false
+        options:
+          - label: "src/"               description: "Source directory file"
+          - label: "README.md"          description: "Project readme"
+  ```
+  The user can type any path via "Other".
+  After getting the path:
+  1. Reject absolute paths outside the current working directory
+  2. Reject paths containing `..` that escape the project root
+  3. Reject UNC paths (`\\` or `//` prefix)
+  4. Validate the file exists using the Read tool
+  If the path escapes the project: `[ERROR] Context file must be within the project directory`
+  If the file doesn't exist: `[ERROR] Context file not found: {PATH}`
+  If valid, set context to `file={user_provided_path}`.
+
+If proposer and challenger resolve to the same tool after selection, show error and re-ask for challenger.
+
+### Phase 3: Spawn Debate Orchestrator
+
+With all parameters resolved, spawn the debate orchestrator agent:
+
+```
+Task:
+  subagent_type: "debate:debate-orchestrator"
+  model: opus
+  prompt: |
+    Execute a structured debate with these pre-resolved parameters:
+    - topic: [topic]
+    - proposer: [proposer tool]
+    - challenger: [challenger tool]
+    - effort: [effort]
+    - rounds: [rounds]
+    - model_proposer: [model or "omit"]
+    - model_challenger: [model or "omit"]
+
+    If model is "omit" or empty, do NOT include --model in consult skill invocations. The consult skill will use effort-based defaults.
+    - context: [context or "none"]
+
+    Follow the debate skill templates. Display each round progressively.
+    Deliver a verdict that picks a winner.
+```
+
+### Phase 4: Present Results
+
+Display the orchestrator's output directly. It includes:
+- Progressive round-by-round output (displayed as each round completes)
+- Final synthesis with verdict, agreements, disagreements, and recommendation
+
+On failure: `[ERROR] Debate Failed: {specific error message}`
+
+## Error Handling
+
+| Error | Output |
+|-------|--------|
+| No topic provided | `[ERROR] Usage: /debate "your topic" or /debate codex vs gemini about your topic` |
+| Tool not installed | `[ERROR] {tool} is not installed. Install with: {install command}` |
+| Fewer than 2 tools | `[ERROR] Debate requires at least 2 AI CLI tools installed.` |
+| Same tool for both | `[ERROR] Proposer and challenger must be different tools.` |
+| Rounds out of range | `[ERROR] Rounds must be 1-5. Got: {rounds}` |
+| Context file not found | `[ERROR] Context file not found: {PATH}` |
+| Orchestrator fails | `[ERROR] Debate failed: {error}` |
+
+## Example Usage
+
+```bash
+# Natural language
+/debate codex vs gemini about microservices vs monolith
+/debate with claude and codex about our auth implementation
+/debate thoroughly gemini vs codex about database schema design
+/debate codex vs gemini 3 rounds about event sourcing
+
+# Explicit flags
+/debate "Should we use event sourcing?" --tools=claude,gemini --rounds=3 --effort=high
+/debate "Redis vs PostgreSQL for caching" --tools=codex,opencode
+
+# Mixed
+/debate codex vs gemini --effort=max about performance optimization strategies
+```

package/plugins/debate/lib/adapter-transforms.js

@@ -0,0 +1,298 @@
+/**
+ * Adapter Transform Functions
+ *
+ * Shared transforms for converting Claude Code plugin content into
+ * OpenCode and Codex adapter formats. Used by:
+ *   - bin/cli.js (npm installer)
+ *   - scripts/dev-install.js (development installer)
+ *   - scripts/gen-adapters.js (static adapter generation)
+ *
+ * @module adapter-transforms
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+const discovery = require('./discovery');
+
+function transformBodyForOpenCode(content, repoRoot) {
+  content = content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, '${PLUGIN_ROOT}');
+  content = content.replace(/\$CLAUDE_PLUGIN_ROOT/g, '$PLUGIN_ROOT');
+
+  // Replace .claude/ paths with .opencode/ but preserve platform documentation lists
+  // that enumerate all three platforms (Claude Code: .claude/, OpenCode: .opencode/, Codex: .codex/)
+  // Also preserve {AI_STATE_DIR} references which are platform-agnostic
+  content = content.replace(/\.claude\//g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    // Skip if inside a platform enumeration (e.g., "Claude Code: `.claude/`")
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode/';
+  });
+  content = content.replace(/\.claude'/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return ".opencode'";
+  });
+  content = content.replace(/\.claude"/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode"';
+  });
+  content = content.replace(/\.claude`/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode`';
+  });
+
+  const plugins = discovery.discoverPlugins(repoRoot);
+  if (plugins.length > 0) {
+    const pluginNames = plugins.join('|');
+    content = content.replace(new RegExp('`(' + pluginNames + '):([a-z-]+)`', 'g'), '`$2`');
+    content = content.replace(new RegExp('(' + pluginNames + '):([a-z-]+)', 'g'), '$2');
+  }
+
+  content = content.replace(
+    /```(\w*)\n([\s\S]*?)```/g,
+    (match, lang, code) => {
+      const langLower = (lang || '').toLowerCase();
+
+      if (langLower === 'bash' || langLower === 'shell' || langLower === 'sh') {
+        if (code.includes('node -e') && code.includes('require(')) {
+          return '*(Bash command with Node.js require - adapt for OpenCode)*';
+        }
+        return match;
+      }
+
+      if (!lang && (code.trim().startsWith('gh ') || code.trim().startsWith('glab ') ||
+          code.trim().startsWith('git ') || code.trim().startsWith('#!'))) {
+        return match;
+      }
+
+      if (code.includes('require(') || code.includes('Task(') ||
+          code.includes('const ') || code.includes('let ') ||
+          code.includes('function ') || code.includes('=>') ||
+          code.includes('async ') || code.includes('await ')) {
+
+        let instructions = '';
+
+        const taskMatches = [...code.matchAll(/(?:await\s+)?Task\s*\(\s*\{[^}]*subagent_type:\s*["'](?:[^"':]+:)?([^"']+)["'][^}]*\}\s*\)/gs)];
+        for (const taskMatch of taskMatches) {
+          const agent = taskMatch[1];
+          instructions += `- Invoke \`@${agent}\` agent\n`;
+        }
+
+        const phaseMatches = code.match(/startPhase\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+        if (phaseMatches) {
+          for (const pm of phaseMatches) {
+            const phase = pm.match(/['"]([^'"]+)['"]/)[1];
+            instructions += `- Phase: ${phase}\n`;
+          }
+        }
+
+        if (code.includes('AskUserQuestion')) {
+          instructions += '- Use AskUserQuestion tool for user input\n';
+        }
+
+        if (code.includes('EnterPlanMode')) {
+          instructions += '- Use EnterPlanMode for user approval\n';
+        }
+
+        if (instructions) {
+          return instructions;
+        }
+
+        return '*(JavaScript reference - not executable in OpenCode)*';
+      }
+
+      return match;
+    }
+  );
+
+  content = content.replace(/\*\(Reference - adapt for OpenCode\)\*/g, '');
+
+  content = content.replace(/await\s+Task\s*\(\s*\{[\s\S]*?\}\s*\);?/g, (match) => {
+    const agentMatch = match.match(/subagent_type:\s*["'](?:[^"':]+:)?([^"']+)["']/);
+    if (agentMatch) {
+      return `Invoke \`@${agentMatch[1]}\` agent`;
+    }
+    return '*(Task call - use @agent-name syntax)*';
+  });
+
+  content = content.replace(/(?:const|let|var)\s+\{?[^}=\n]+\}?\s*=\s*require\s*\([^)]+\);?/g, '');
+  content = content.replace(/require\s*\(['"][^'"]+['"]\)/g, '');
+
+  if (content.includes('agent')) {
+    const note = `
+> **OpenCode Note**: Invoke agents using \`@agent-name\` syntax.
+> Available agents: task-discoverer, exploration-agent, planning-agent,
+> implementation-agent, deslop-agent, delivery-validator, sync-docs-agent, consult-agent
+> Example: \`@exploration-agent analyze the codebase\`
+
+`;
+    content = content.replace(/^(---\n[\s\S]*?---\n)/, `$1${note}`);
+  }
+
+  if (content.includes('Master Workflow Orchestrator') && content.includes('No Shortcuts Policy')) {
+    const policySection = `
+## Phase 1: Policy Selection (Built-in Options)
+
+Ask the user these questions using AskUserQuestion:
+
+**Question 1 - Source**: "Where should I look for tasks?"
+- GitHub Issues - Use \`gh issue list\` to find issues
+- GitLab Issues - Use \`glab issue list\` to find issues
+- Local tasks.md - Read from PLAN.md, tasks.md, or TODO.md in the repo
+- Custom - User specifies their own source
+- Other - User describes source, you figure it out
+
+**Question 2 - Priority**: "What type of tasks to prioritize?"
+- All - Consider all tasks, pick by score
+- Bugs - Focus on bug fixes
+- Security - Security issues first
+- Features - New feature development
+
+**Question 3 - Stop Point**: "How far should I take this task?"
+- Merged - Until PR is merged to main
+- PR Created - Stop after creating PR
+- Implemented - Stop after local implementation
+- Deployed - Deploy to staging
+- Production - Full production deployment
+
+After user answers, proceed to Phase 2 with the selected policy.
+
+`;
+    if (content.includes('OpenCode Note')) {
+      content = content.replace(/(Example:.*analyze the codebase\`\n\n)/, `$1${policySection}`);
+    }
+  }
+
+  return content;
+}
+
+function transformCommandFrontmatterForOpenCode(content) {
+  return content.replace(
+    /^---\n([\s\S]*?)^---/m,
+    (match, frontmatter) => {
+      // Parse existing frontmatter
+      const lines = frontmatter.trim().split('\n');
+      const parsed = {};
+      for (const line of lines) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx > 0) {
+          const key = line.substring(0, colonIdx).trim();
+          const value = line.substring(colonIdx + 1).trim();
+          parsed[key] = value;
+        }
+      }
+
+      // Build OpenCode command frontmatter
+      let opencodeFrontmatter = '---\n';
+      if (parsed.description) opencodeFrontmatter += `description: ${parsed.description}\n`;
+      opencodeFrontmatter += 'agent: general\n';
+      // Don't include argument-hint or allowed-tools (not supported)
+      opencodeFrontmatter += '---';
+      return opencodeFrontmatter;
+    }
+  );
+}
+
+function transformAgentFrontmatterForOpenCode(content, options) {
+  const { stripModels = true } = options || {};
+
+  return content.replace(
+    /^---\n([\s\S]*?)^---/m,
+    (match, frontmatter) => {
+      // Parse existing frontmatter
+      const lines = frontmatter.trim().split('\n');
+      const parsed = {};
+      for (const line of lines) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx > 0) {
+          const key = line.substring(0, colonIdx).trim();
+          const value = line.substring(colonIdx + 1).trim();
+          parsed[key] = value;
+        }
+      }
+
+      // Build OpenCode frontmatter
+      let opencodeFrontmatter = '---\n';
+      if (parsed.name) opencodeFrontmatter += `name: ${parsed.name}\n`;
+      if (parsed.description) opencodeFrontmatter += `description: ${parsed.description}\n`;
+      opencodeFrontmatter += 'mode: subagent\n';
+
+      // Map model names - only include if NOT stripping
+      if (parsed.model && !stripModels) {
+        const modelMap = {
+          'sonnet': 'anthropic/claude-sonnet-4',
+          'opus': 'anthropic/claude-opus-4',
+          'haiku': 'anthropic/claude-haiku-3-5'
+        };
+        opencodeFrontmatter += `model: ${modelMap[parsed.model] || parsed.model}\n`;
+      }
+
+      // Convert tools to permissions
+      if (parsed.tools) {
+        opencodeFrontmatter += 'permission:\n';
+        const tools = parsed.tools.toLowerCase();
+        opencodeFrontmatter += `  read: ${tools.includes('read') ? 'allow' : 'deny'}\n`;
+        opencodeFrontmatter += `  edit: ${tools.includes('edit') || tools.includes('write') ? 'allow' : 'deny'}\n`;
+        opencodeFrontmatter += `  bash: ${tools.includes('bash') ? 'allow' : 'ask'}\n`;
+        opencodeFrontmatter += `  glob: ${tools.includes('glob') ? 'allow' : 'deny'}\n`;
+        opencodeFrontmatter += `  grep: ${tools.includes('grep') ? 'allow' : 'deny'}\n`;
+      }
+
+      opencodeFrontmatter += '---';
+      return opencodeFrontmatter;
+    }
+  );
+}
+
+function transformSkillBodyForOpenCode(content, repoRoot) {
+  return transformBodyForOpenCode(content, repoRoot);
+}
+
+function transformForCodex(content, options) {
+  const { skillName, description, pluginInstallPath } = options;
+
+  // Escape description for YAML: wrap in double quotes, escape backslashes and internal quotes
+  const escapedDescription = description.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const yamlDescription = `"${escapedDescription}"`;
+
+  if (content.startsWith('---')) {
+    // Replace existing frontmatter with Codex-compatible format
+    content = content.replace(
+      /^---\n[\s\S]*?\n---\n/,
+      `---\nname: ${skillName}\ndescription: ${yamlDescription}\n---\n`
+    );
+  } else {
+    // Add new frontmatter
+    content = `---\nname: ${skillName}\ndescription: ${yamlDescription}\n---\n\n${content}`;
+  }
+
+  // Transform PLUGIN_ROOT to actual installed path (or placeholder) for Codex
+  content = content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginInstallPath);
+  content = content.replace(/\$CLAUDE_PLUGIN_ROOT/g, pluginInstallPath);
+  content = content.replace(/\$\{PLUGIN_ROOT\}/g, pluginInstallPath);
+  content = content.replace(/\$PLUGIN_ROOT/g, pluginInstallPath);
+
+  // Transform AskUserQuestion → request_user_input for Codex native tool
+  content = content.replace(/AskUserQuestion/g, 'request_user_input');
+
+  // Remove multiSelect lines (not supported in Codex)
+  content = content.replace(/^[ \t]*multiSelect:.*\n?/gm, '');
+
+  // Inject Codex note about required id field after request_user_input blocks
+  content = content.replace(
+    /^([ \t]*request_user_input:\s*)$/gm,
+    '$1\n> **Codex**: Each question MUST include a unique `id` field (e.g., `id: "q1"`).'
+  );
+
+  return content;
+}
+
+module.exports = {
+  transformBodyForOpenCode,
+  transformCommandFrontmatterForOpenCode,
+  transformAgentFrontmatterForOpenCode,
+  transformSkillBodyForOpenCode,
+  transformForCodex
+};