
agent-alchemy-opencode-tools
Interactive toolkit for creating and maintaining OpenCode-compatible skills, agents, and commands
- version
- 0.1.3
- GitHub stars
- 45
Install
/plugin install agent-alchemy-opencode-tools@agent-alchemyRun it inside Claude Code after adding the marketplace with /plugin marketplace add sequenzia/agent-alchemy.
Contents
Discovered from sourceSkills 7
Create OpenCode Agent
You are initiating the OpenCode agent creation workflow. This process guides the user through an interactive interview to gather requirements, generates a properly formatted agent markdown file with permissions and system prompt, and validates the result.
Critical Rules
AskUserQuestion is MANDATORY
IMPORTANT: You MUST use the AskUserQuestion tool for ALL questions to the user. Never ask questions through regular text output.
Phase 1: Load References
Read the OpenCode platform overview and agent guide:
- Read
${CLAUDE_PLUGIN_ROOT}/references/platform-overview.md - Read
${CLAUDE_PLUGIN_ROOT}/references/agent-guide.md
Phase 2: Interview
Gather requirements through a structured interview.
Round 1: Identity
Question 1 — Agent Name:
- Header: "Agent Name"
- Question: "What should this agent be named? Use kebab-case (e.g.,
code-reviewer,test-runner)." - Options:
- "I'll type the name" — Let me provide a custom name
Question 2 — Purpose:
- Header: "Purpose"
- Question: "What does this agent do? Describe its main function."
- Options:
- "Code analysis" — Reviews or analyzes code
- "Code generation" — Writes new code or modifies existing code
- "Research" — Gathers information from docs, web, or codebase
- "Automation" — Executes multi-step workflows
Question 3 — Mode:
- Header: "Mode"
- Question: "How will this agent be used?"
- Options:
- "Primary (Recommended)" — Interactive agent the user switches to via @name
- "Subagent" — Spawned by other skills/agents via the task tool
- "Both" — Works as primary and subagent
- multiSelect: false
Round 2: Model & Behavior
Question 1 — Model Tier:
- Header: "Model"
- Question: "What model tier should this agent use?"
- Options:
- "Sonnet (Recommended)" — Good balance of capability and speed
- "Opus" — Maximum reasoning capability for complex tasks
- "Haiku" — Fast and lightweight for simple tasks
- "Default" — Use the session's current model
- multiSelect: false
Question 2 — Temperature:
- Header: "Temperature"
- Question: "How deterministic should responses be?"
- Options:
- "Low (0.3)" — More consistent, factual responses
- "Default (0.7)" — Balanced creativity and consistency
- "High (0.9)" — More creative and varied responses
- multiSelect: false
Question 3 — Steps Limit:
- Header: "Steps"
- Question: "Should there be a limit on agentic iterations?"
- Options:
- "Default" — No explicit limit
- "Conservative (25)" — Limit to prevent runaway loops
- "Generous (100)" — Allow extended multi-step workflows
- "Custom" — I'll specify a number
- multiSelect: false
Round 3: Permissions
Question 1 — Permission Level:
- Header: "Permissions"
- Question: "What permission level should the agent have?"
- Options:
- "Read-only" — Can read, glob, grep only. No writes, edits, or bash.
- "Standard" — Read allowed, write/edit/bash require approval
- "Full access" — All tools auto-allowed
- "Custom" — I'll configure per-tool permissions
- multiSelect: false
If "Custom" selected:
Question 2 — File Operations:
- Header: "File Ops"
- Question: "File operation permissions?"
- Options:
- "read: allow, write: ask, edit: ask" — Read freely, ask for writes
- "read: allow, write: allow, edit: allow" — Full file access
- "read: allow, write: deny, edit: deny" — Read only
- multiSelect: false
Question 3 — Execution:
- Header: "Execution"
- Question: "Bash execution permission?"
- Options:
- "deny" — No shell access
- "ask" — Require approval for each command
- "allow" — Auto-approve all commands
- multiSelect: false
Question 4 — Web Access:
- Header: "Web"
- Question: "Web access permissions?"
- Options:
- "No web access" — Deny websearch and webfetch
- "Search only" — Allow websearch, deny webfetch
- "Full web access" — Allow both websearch and webfetch
- multiSelect: false
Round 4: System Prompt
Question 1 — Prompt Focus:
- Header: "Focus Areas"
- Question: "What should the system prompt emphasize? Select all that apply."
- Options:
- "Structured output" — Agent produces formatted reports or specific formats
- "Tool usage patterns" — Agent follows specific tool usage workflows
- "Domain expertise" — Agent has specialized knowledge in a domain
- "Phase-based workflow" — Agent works through numbered phases
- multiSelect: true
Question 2 — Constraints:
- Header: "Constraints"
- Question: "Any important constraints for the agent?"
- Options:
- "No destructive actions" — Never delete files or drop data
- "Stay in scope" — Don't explore beyond the assigned area
- "Concise output" — Keep responses short and focused
- "No constraints" — Let the agent operate freely
- multiSelect: true
Round 5: Location & Display
Question 1 — Location:
- Header: "Location"
- Question: "Where should the agent be created?"
- Options:
- "Project (.opencode/agents/)" — Available only in this project
- "Global (~/.config/opencode/agents/)" — Available in all projects
- "Custom path" — I'll specify the directory
- multiSelect: false
Question 2 — Display:
- Header: "Display"
- Question: "Agent display preferences?"
- Options:
- "Default" — Standard display, visible in @-mention list
- "Custom color" — I'll pick a color
- "Hidden" — Don't show in @-mention list
- multiSelect: false
Interview Summary
Present a comprehensive summary:
## Agent Summary
- **Name**: {name}
- **Description**: {generated description}
- **Mode**: {primary/subagent/all}
- **Model**: {provider/model-id}
- **Temperature**: {value}
- **Steps**: {value or "default"}
- **Permissions**: {summary}
- **Focus areas**: {list}
- **Constraints**: {list}
- **Location**: {path}
Use AskUserQuestion to confirm:
- Header: "Confirm"
- Question: "Does this look correct? Ready to generate the agent?"
- Options:
- "Yes, generate it" — Proceed with generation
- "Make changes" — I want to adjust something
Phase 3: Generate
Spawn the generator agent:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-generator"
prompt: |
Generate an OpenCode agent with these specifications:
Type: agent
Name: {name}
Description: {description}
Mode: {mode}
Model: {model}
Temperature: {temperature}
Steps: {steps}
Permissions: {permission object}
Color: {color or null}
Hidden: {true/false}
System prompt focus: {focus areas}
Constraints: {constraints}
Target path: {target directory}/agents/{name}.md
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/agent-guide.md
Template: ${CLAUDE_PLUGIN_ROOT}/references/templates/agent-template.md
Interview notes:
{all gathered requirements}
Phase 4: Validate
Spawn the validator agent:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-validator"
prompt: |
Validate the following OpenCode artifact:
Type: agent
Path: {path to generated file}
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/agent-guide.md
If validation fails with errors, fix the issues and re-validate.
Phase 5: Present
Present the generated agent:
- Read the generated file
- Show the file contents with syntax highlighting
- Explain key design decisions:
- Permission model rationale
- Why certain mode was chosen
- Model tier selection reasoning
- System prompt structure
- Show validation results
- Explain how to use the agent:
- Primary:
@{name}in the TUI - Subagent:
task({ prompt: "...", command: "{name}" })
- Primary:
- If applicable, explain how to configure the model in
opencode.json
CRITICAL: Complete ALL 5 phases before finishing.
Create OpenCode Command
You are initiating the OpenCode command creation workflow. This process guides the user through an interactive interview to gather requirements, generates a properly formatted command markdown file, and validates the result.
Critical Rules
AskUserQuestion is MANDATORY
IMPORTANT: You MUST use the AskUserQuestion tool for ALL questions to the user. Never ask questions through regular text output.
Phase 1: Load References
Read the OpenCode platform overview and command guide:
- Read
${CLAUDE_PLUGIN_ROOT}/references/platform-overview.md - Read
${CLAUDE_PLUGIN_ROOT}/references/command-guide.md
Phase 2: Interview
Gather requirements through a structured interview.
Round 1: Basics
Question 1 — Command Name:
- Header: "Command Name"
- Question: "What should this command be named? It will be invoked as
/{name}. Use kebab-case." - Options:
- "I'll type the name" — Let me provide a custom name
Question 2 — Purpose:
- Header: "Purpose"
- Question: "What does this command do?"
- Options:
- "Workflow shortcut" — Automates a frequently used multi-step process
- "Template task" — Structured prompt with variable inputs
- "Scripted operation" — Executes specific tool sequences
- "Custom" — I'll describe it
Question 3 — Description:
- Header: "Description"
- Question: "Briefly describe what this command does (shown in the command list)."
- Options:
- "I'll type a description" — Let me write a custom description
Round 2: Variables & Model
Question 1 — Variables:
- Header: "Variables"
- Question: "Does the command need user-provided input via $VARIABLE placeholders?"
- Options:
- "Yes, I'll list them" — I need specific named variables
- "Just $ARGUMENTS" — A single free-text argument
- "No variables" — The command works without user input
- multiSelect: false
If "Yes":
Question 2 — Variable Names:
- Header: "Var Names"
- Question: "List the variable names (e.g., FILE_PATH, TARGET_BRANCH, OUTPUT_FORMAT). Each becomes a $VARIABLE prompt."
- Options:
- "I'll type them" — Let me list the variable names
Question 3 — Model Override:
- Header: "Model"
- Question: "Should this command use a specific model? (Commands are the only extension type with per-invocation model override.)"
- Options:
- "No override (Recommended)" — Use the session's current model
- "Opus" — Use anthropic/claude-opus-4-6 for complex reasoning
- "Sonnet" — Use anthropic/claude-sonnet-4-6 for balanced performance
- "Haiku" — Use anthropic/claude-haiku-4-5 for speed
- multiSelect: false
Question 4 — Agent Routing:
- Header: "Agent"
- Question: "Should this command be routed to a specific agent?"
- Options:
- "No (Recommended)" — Use the current agent context
- "Yes" — Route to a specific named agent
- multiSelect: false
Round 3: Location
Question 1 — Location:
- Header: "Location"
- Question: "Where should the command be created?"
- Options:
- "Project (.opencode/commands/)" — Available only in this project
- "Global (~/.config/opencode/commands/)" — Available in all projects
- "Custom path" — I'll specify the directory
- multiSelect: false
Interview Summary
Present a summary:
## Command Summary
- **Name**: {name} (invoked as /{name})
- **Description**: {description}
- **Variables**: {list of $VARIABLE names or "none"}
- **Model override**: {model or "none"}
- **Agent**: {agent name or "none"}
- **Location**: {path}
Use AskUserQuestion to confirm:
- Header: "Confirm"
- Question: "Does this look correct? Ready to generate the command?"
- Options:
- "Yes, generate it"
- "Make changes"
Phase 3: Generate
Spawn the generator agent:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-generator"
prompt: |
Generate an OpenCode command with these specifications:
Type: command
Name: {name}
Description: {description}
Variables: {list of $VARIABLE names}
Model override: {model or "none"}
Agent: {agent name or "none"}
Subtask: {true/false}
Purpose: {detailed purpose from interview}
Target path: {target directory}/commands/{name}.md
NOTE: Commands support `agent` (which agent executes) and `subtask` (force subagent execution) frontmatter fields in addition to `model` and `description`.
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/command-guide.md
Template: ${CLAUDE_PLUGIN_ROOT}/references/templates/command-template.md
Interview notes:
{all gathered requirements}
Phase 4: Validate
Spawn the validator agent:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-validator"
prompt: |
Validate the following OpenCode artifact:
Type: command
Path: {path to generated file}
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/command-guide.md
If validation fails with errors, fix and re-validate.
Phase 5: Present
Present the generated command:
- Read the generated file
- Show the file contents
- Explain key design decisions:
- $VARIABLE placeholder usage
- Model override rationale (if applicable)
- Why command vs skill was the right choice
- Show validation results
- Explain how to invoke:
/{name}in the OpenCode TUI - If variables are present, show what the user will be prompted for
CRITICAL: Complete ALL 5 phases before finishing.
Create OpenCode Skill
You are initiating the OpenCode skill creation workflow. This process guides the user through an interactive interview to gather requirements, generates a properly formatted SKILL.md file, and validates the result.
Critical Rules
AskUserQuestion is MANDATORY
IMPORTANT: You MUST use the AskUserQuestion tool for ALL questions to the user. Never ask questions through regular text output.
- Every interview question → AskUserQuestion
- Confirmation questions → AskUserQuestion
- Clarifying questions → AskUserQuestion
Text output should only be used for summaries, explanations, and presenting information.
Phase 1: Load References
Read the OpenCode platform overview and skill guide:
- Read
${CLAUDE_PLUGIN_ROOT}/references/platform-overview.md - Read
${CLAUDE_PLUGIN_ROOT}/references/skill-guide.md
Store the reference content internally for use throughout the workflow.
Phase 2: Interview
Gather requirements through a structured interview using AskUserQuestion.
Round 1: Basics
Ask these questions using AskUserQuestion (max 4 per call):
Question 1 — Skill Name:
- Header: "Skill Name"
- Question: "What should this skill be named? Use kebab-case (e.g.,
code-review,deploy-check)." - Options:
- "I'll type the name" — Let me provide a custom name
Question 2 — Purpose:
- Header: "Purpose"
- Question: "What does this skill do? Describe its main function."
- Options:
- "Code analysis" — Analyzes code for patterns, issues, or quality
- "Workflow automation" — Automates a multi-step process
- "Content generation" — Generates code, docs, or other content
Question 3 — User-Invocable:
- Header: "Invocable"
- Question: "Should users be able to invoke this skill directly (via
/skill-name)?" - Options:
- "Yes (Recommended)" — Users can invoke it from the command dialog
- "No" — Helper skill only loaded by other skills
- multiSelect: false
Round 2: Details
Question 1 — Target Audience:
- Header: "Audience"
- Question: "Who is the primary user of this skill?"
- Options:
- "Developers" — Software developers working on code
- "DevOps/SRE" — Operations and reliability engineers
- "All users" — General-purpose, no specific expertise needed
Question 2 — Variables:
- Header: "Variables"
- Question: "Does the skill need user input via $VARIABLE placeholders? (e.g., $FILE_PATH, $TARGET_BRANCH)"
- Options:
- "Yes" — I need specific input values from the user
- "No" — The skill works without user-provided variables
- "Just $ARGUMENTS" — A single free-text argument is enough
- multiSelect: false
Question 3 — Complexity:
- Header: "Complexity"
- Question: "How complex is the workflow?"
- Options:
- "Simple" — Single phase, straightforward instructions
- "Multi-phase" — 2-4 distinct phases with clear boundaries
- "Complex" — 5+ phases or spawns subagents via task tool
- multiSelect: false
Round 3: Content (if multi-phase or complex)
If the user selected multi-phase or complex:
Question 1 — Phases:
- Header: "Phases"
- Question: "Describe the main phases of the workflow (what happens in each step)."
- Options:
- "I'll describe them" — Let me explain the phases
Question 2 — Tools:
- Header: "Tools"
- Question: "Which tools should the skill primarily use?"
- Options:
- "Read-only" — read, glob, grep only
- "Read + write" — read, glob, grep, write, edit
- "Full access" — All tools including bash
- "Custom" — I'll specify which tools
- multiSelect: false
Round 4: Location and Metadata
Question 1 — Location:
- Header: "Location"
- Question: "Where should the skill be created?"
- Options:
- "Project (.opencode/skills/)" — Available only in this project
- "Global (~/.config/opencode/skills/)" — Available in all projects
- "Custom path" — I'll specify the directory
- multiSelect: false
Question 2 — Additional metadata:
- Header: "Metadata"
- Question: "Any additional metadata to include?"
- Options:
- "Add license (MIT)" — Include MIT license field
- "Add compatibility range" — Specify OpenCode version range
- "Skip metadata" — No additional metadata needed
- multiSelect: true
Interview Summary
After completing the interview rounds, present a summary of the gathered requirements:
## Skill Summary
- **Name**: {name}
- **Description**: {generated from purpose + details}
- **User-invocable**: {yes/no}
- **Variables**: {list or "none"}
- **Phases**: {count and brief description}
- **Tools**: {tool set}
- **Location**: {path}
Use AskUserQuestion to confirm:
- Header: "Confirm"
- Question: "Does this look correct? Ready to generate the skill?"
- Options:
- "Yes, generate it" — Proceed with generation
- "Make changes" — I want to adjust something
If "Make changes", ask what to change and update accordingly.
Phase 3: Generate
Spawn the generator agent to create the skill file:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-generator"
prompt: |
Generate an OpenCode skill with these specifications:
Type: skill
Name: {name}
Description: {description}
User-invocable: {true/false}
Variables: {list of $VARIABLE placeholders}
Phases: {phase descriptions}
Tool guidance: {which tools to use/avoid}
Target path: {target directory}/skills/{name}/SKILL.md
IMPORTANT: The `name` field is REQUIRED in frontmatter. Set it to "{name}" (must match the directory name).
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/skill-guide.md
Template: ${CLAUDE_PLUGIN_ROOT}/references/templates/skill-template.md
Interview notes:
{all gathered requirements}
Phase 4: Validate
Spawn the validator agent to check the generated file:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-validator"
prompt: |
Validate the following OpenCode artifact:
Type: skill
Path: {path to generated file}
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/skill-guide.md
If validation fails with errors, fix the issues and re-validate.
Phase 5: Present
Present the generated skill to the user:
- Read the generated file
- Show the file contents with syntax highlighting
- Explain key design decisions:
- Why certain frontmatter fields were included/excluded
- How phases were structured
- How $VARIABLE placeholders work
- Show the validation results (pass/warnings)
- Explain how to invoke the skill:
/{name}in the OpenCode TUI
CRITICAL: Complete ALL 5 phases before finishing.
OpenCode Tool Dev
You are initiating the unified OpenCode tool development workflow. This process triages what the user needs, detects dependencies between artifacts, builds an execution plan, and delegates to the existing type-specific skills — reusing their interview flows and generation logic.
Critical Rules
AskUserQuestion is MANDATORY
IMPORTANT: You MUST use the AskUserQuestion tool for ALL questions to the user. Never ask questions through regular text output.
- Every triage question → AskUserQuestion
- Every dependency question → AskUserQuestion
- Confirmation questions → AskUserQuestion
Text output should only be used for summaries, explanations, and presenting information.
Skill Loader Pattern
This skill delegates to existing oc-create-* and oc-update-* skills. When executing a tool creation/update:
- Read the target skill's SKILL.md
- Follow its instructions as written
- Pre-fill known answers from triage to skip redundant questions
- The loaded skill is the single source of truth for its artifact type
Phase 1: Load References
Read the OpenCode platform overview for general context:
- Read
${CLAUDE_PLUGIN_ROOT}/references/platform-overview.md
Type-specific guides (skill-guide.md, agent-guide.md, command-guide.md) are loaded later by the delegated skill — do not load them here.
Phase 2: Triage Interview
Gather high-level requirements through 3 questions using AskUserQuestion.
Question 1 — Action:
- Header: "Action"
- Question: "What would you like to do?"
- Options:
- "Create new (Recommended)" — Create a new OpenCode tool from scratch
- "Update existing" — Update an existing tool to match current best practices
- multiSelect: false
Question 2 — Tool Type:
- Header: "Tool Type"
- Question: "What type of OpenCode tool?"
- Options:
- "Skill" — A SKILL.md workflow with phases, tools, and structured prompts
- "Agent" — A custom agent persona with model, permissions, and system prompt
- "Command" — A workflow shortcut with $VARIABLE placeholders and optional model override
- multiSelect: false
Question 3 — Name & Description:
- Header: "Describe"
- Question: "What should this tool be named and what will it do? Provide a name (kebab-case) and brief purpose."
- Options:
- "I'll describe it" — Let me provide the name and purpose
- multiSelect: false
If "Update existing" was selected:
Ask an additional question to locate the existing artifact:
Question 4 — Locate Artifact:
- Header: "Locate"
- Question: "How should I find the existing tool?"
- Options:
- "Search workspace" — Search for OpenCode artifacts in the project
- "I'll provide the path" — Let me specify the file path directly
- multiSelect: false
If "Search workspace": search using the same discovery patterns as the oc-update-* skills:
Globfor.opencode/{type}s/*/SKILL.md(skills) or.opencode/{type}s/*.md(agents/commands)Globfor.claude/{type}s/*/SKILL.mdor.claude/{type}s/*.mdGlobfor.agents/{type}s/*/SKILL.mdor.agents/{type}s/*.md- Present found artifacts using
AskUserQuestionfor selection
Store triage results: action, type, name, description, and optionally the artifact path.
Phase 3: Dependency Detection Interview
Based on the primary tool type, ask targeted dependency questions using AskUserQuestion.
If creating/updating a Skill:
Question 1 — Custom Agent:
- Header: "Agent?"
- Question: "Does this skill need a custom subagent (spawned via the task tool)?"
- Options:
- "No (Recommended)" — The skill works without a custom agent
- "Yes" — I need a custom agent for this skill
- multiSelect: false
If "Yes": ask for the agent name and brief purpose via AskUserQuestion.
Question 2 — Supporting Command:
- Header: "Command?"
- Question: "Does this skill need a supporting command (invoked via /{name} in the TUI)?"
- Options:
- "No (Recommended)" — No command needed
- "Yes" — I want a command shortcut for this skill
- multiSelect: false
If "Yes": ask for the command name and brief purpose via AskUserQuestion.
If creating/updating an Agent:
Question 1 — Parent Skill:
- Header: "Skill?"
- Question: "Is this agent used by a skill that also needs creating?"
- Options:
- "No (Recommended)" — Standalone agent
- "Yes" — I also need a skill that uses this agent
- multiSelect: false
If "Yes": ask for the skill name and purpose via AskUserQuestion.
If creating/updating a Command:
Question 1 — Agent Routing:
- Header: "Agent?"
- Question: "Does this command route to an agent that needs creating?"
- Options:
- "No (Recommended)" — Uses the current agent context
- "Yes" — I need a custom agent for this command
- multiSelect: false
If "Yes": ask for the agent name and purpose via AskUserQuestion.
For updates with dependencies:
Question — Related Updates:
- Header: "Related?"
- Question: "Are there related tools that also need updating?"
- Options:
- "No" — Just update the selected tool
- "Yes" — I have related tools to update too
- multiSelect: false
If "Yes": gather the names and types of related tools.
If the user indicates no dependencies in all questions, skip directly to Phase 4.
Phase 4: Plan & Confirm
Build and present the execution plan as a text summary:
## Tool Creation Plan
### Primary Tool
- **Type**: {Skill | Agent | Command}
- **Name**: {name}
- **Action**: {Create | Update}
- **Purpose**: {brief description}
### Dependencies (processed first)
1. {Type}: {name} — {Create | Update} — {brief purpose}
2. ...
(If no dependencies: "No dependencies — single artifact workflow.")
### Execution Order
1. {first dependency}
2. {second dependency}
3. {primary tool}
Confirm the plan using AskUserQuestion:
- Header: "Confirm"
- Question: "Proceed with this plan?"
- Options:
- "Yes, start" — Begin execution in the order shown
- "Modify plan" — I want to change something
- "Cancel" — Abort the workflow
- multiSelect: false
If "Modify plan": ask what to change, update the plan, and re-confirm. If "Cancel": stop the workflow and inform the user.
Phase 5: Execute (dependency order)
Process each item in the plan, in dependency order (agents before skills, skills before commands that reference them).
For each item:
Step 1 — Determine the target skill path:
| Action | Type | Skill Path |
|---|---|---|
| Create | Skill | ${CLAUDE_PLUGIN_ROOT}/skills/oc-create-skill/SKILL.md |
| Create | Agent | ${CLAUDE_PLUGIN_ROOT}/skills/oc-create-agent/SKILL.md |
| Create | Command | ${CLAUDE_PLUGIN_ROOT}/skills/oc-create-command/SKILL.md |
| Update | Skill | ${CLAUDE_PLUGIN_ROOT}/skills/oc-update-skill/SKILL.md |
| Update | Agent | ${CLAUDE_PLUGIN_ROOT}/skills/oc-update-agent/SKILL.md |
| Update | Command | ${CLAUDE_PLUGIN_ROOT}/skills/oc-update-command/SKILL.md |
Step 2 — Read the target skill's SKILL.md.
Step 3 — Follow the loaded skill's instructions with these adjustments:
- Skip Phase 1 (Load References) — platform overview already loaded; the delegated skill's type-specific guide will be loaded by its generator/researcher agent.
- Pre-fill known answers from triage:
- Name → skip the "name" interview question
- Purpose/description → skip the "purpose" interview question
- For updates: artifact path → skip the "locate" phase
- Skip already-answered interview questions — proceed directly to detail questions that were not covered in triage.
- Complete all remaining phases — generation, validation, and presentation for creates; research, analysis, presentation, apply, and validation for updates.
Step 4 — After each artifact completes:
Present a brief completion notice:
✓ {Type} "{name}" — {created | updated} at {path}
Then proceed to the next item in the plan.
Phase 6: Summary
After all items are processed, present a final summary:
## Tool Creation Summary
### Artifacts
| # | Type | Name | Action | Path | Validation |
|---|------|------|--------|------|------------|
| 1 | {type} | {name} | {Created/Updated} | {path} | {Pass/Warnings} |
| 2 | ... | ... | ... | ... | ... |
### Dependencies
- {name} (agent) ← used by → {name} (skill)
- {name} (agent) ← routed from → {name} (command)
(If no dependencies: "All artifacts are independent.")
### Invocation
- Skill: `/{skill-name}` in the OpenCode TUI
- Agent: `@{agent-name}` in the TUI or `task({ command: "{agent-name}" })`
- Command: `/{command-name}` in the TUI
CRITICAL: Complete ALL 6 phases before finishing.
Update OpenCode Agent
You are initiating the OpenCode agent update workflow. This process locates an existing agent, researches current platform best practices, analyzes the agent for outdated patterns, and applies updates with validation.
Critical Rules
AskUserQuestion is MANDATORY
IMPORTANT: You MUST use the AskUserQuestion tool for ALL questions to the user. Never ask questions through regular text output.
Phase 1: Load References
Read the OpenCode platform overview and agent guide:
- Read
${CLAUDE_PLUGIN_ROOT}/references/platform-overview.md - Read
${CLAUDE_PLUGIN_ROOT}/references/agent-guide.md
Phase 2: Locate Agent
Find the agent to update.
If $ARGUMENTS is provided:
- Check if the argument is a file path — read it directly
- If it's an agent name — search for
{name}.mdin known directories
If no arguments:
- Search for OpenCode agents in the workspace:
Globfor.opencode/agents/*.mdGlobfor~/.config/opencode/agents/*.md
- Present found agents using
AskUserQuestion:- Header: "Select Agent"
- Question: "Which agent would you like to update?"
- Options: List found agents (up to 4; include "Other" for custom path)
Read the selected agent file and store its contents.
Phase 3: Research
Spawn the researcher agent to check latest documentation:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-researcher"
prompt: |
Research the latest OpenCode documentation for agent format compatibility.
Artifact type: agent
Current artifact content:
---
{contents of the agent file}
---
Specific questions:
1. Are there any new agent frontmatter fields?
2. Have permission syntax rules changed?
3. Are there new agent modes or capabilities?
4. Any changes to subagent behavior or limitations?
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/agent-guide.md
Phase 4: Analyze
Compare the existing agent against current best practices:
Frontmatter Issues
| Issue | Detection | Fix |
|---|---|---|
name field present | Should not exist — name from filename | Remove |
skills field present | Skills not assignable to agents | Remove |
Invalid mode value | Must be primary, subagent, or all (default: all) | Fix or default to all |
| Wrong model format | Must be provider/model-id | Convert |
| Temperature out of range | Must be 0.0-1.0 | Clamp to valid range |
top_p out of range | Must be 0.0-1.0 if present | Clamp to valid range |
| Invalid permission syntax | Values must be allow/ask/deny/true/false | Fix syntax |
Missing description | Required field | Add based on agent content |
Body Issues
| Issue | Detection | Fix |
|---|---|---|
Subagent uses question | Subagents can't use question tool | Add note or restructure |
| Claude Code tool names | AskUserQuestion instead of question | Convert to OpenCode names |
mcp__ format | Double-underscore MCP naming | Convert to single-underscore |
${CLAUDE_PLUGIN_ROOT} refs | Claude Code path variable | Remove or convert |
| Missing purpose statement | No clear first sentence | Add purpose statement |
| No output format section | Agent should specify output | Add output format |
Permission Issues
| Issue | Detection | Fix |
|---|---|---|
| Glob pattern syntax errors | Invalid patterns in permission rules | Fix syntax |
| Overly permissive subagent | Subagent with full write/bash access | Suggest tightening |
| Missing common tools | No read/glob/grep permissions set | Add basic permissions |
Phase 5: Present Findings
Present the analysis organized by severity:
## Update Analysis: {agent-name}
### Errors (must fix)
{list with explanations}
### Warnings (should fix)
{list with explanations}
### Suggestions
{list with explanations}
### Research Notes
{findings from researcher agent}
Use AskUserQuestion for approval:
- Header: "Apply Updates"
- Question: "Would you like to apply these updates?"
- Options:
- "Apply all" — Fix everything
- "Errors and warnings only"
- "Errors only"
- "Cancel"
- multiSelect: false
Phase 6: Apply Updates
Apply changes based on user selection:
- Use
Editto modify the agent file - Fix frontmatter first, then body content
- Preserve the agent's intent and system prompt personality
Phase 7: Validate
Spawn the validator agent:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-validator"
prompt: |
Validate the following OpenCode artifact:
Type: agent
Path: {path to updated file}
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/agent-guide.md
Present validation results and a before/after summary of changes.
CRITICAL: Complete ALL 7 phases before finishing.
Update OpenCode Command
You are initiating the OpenCode command update workflow. This process locates an existing command, researches current platform best practices, analyzes the command for issues, and applies updates with validation.
Critical Rules
AskUserQuestion is MANDATORY
IMPORTANT: You MUST use the AskUserQuestion tool for ALL questions to the user. Never ask questions through regular text output.
Phase 1: Load References
Read the OpenCode platform overview and command guide:
- Read
${CLAUDE_PLUGIN_ROOT}/references/platform-overview.md - Read
${CLAUDE_PLUGIN_ROOT}/references/command-guide.md
Phase 2: Locate Command
Find the command to update.
If $ARGUMENTS is provided:
- Check if the argument is a file path — read it directly
- If it's a command name — search for
{name}.mdin known directories
If no arguments:
- Search for OpenCode commands in the workspace:
Globfor.opencode/commands/*.mdGlobfor~/.config/opencode/commands/*.md
- Present found commands using
AskUserQuestion:- Header: "Select Command"
- Question: "Which command would you like to update?"
- Options: List found commands (up to 4; include "Other" for custom path)
Read the selected command file and store its contents.
Phase 3: Research
Spawn the researcher agent to check latest documentation:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-researcher"
prompt: |
Research the latest OpenCode documentation for command format compatibility.
Artifact type: command
Current artifact content:
---
{contents of the command file}
---
Specific questions:
1. Are there any new command frontmatter fields?
2. Has the $VARIABLE system changed?
3. Are there new command discovery paths?
4. Any changes to the model override behavior?
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/command-guide.md
Phase 4: Analyze
Compare the existing command against current best practices:
Frontmatter Issues
| Issue | Detection | Fix |
|---|---|---|
| Wrong model format | Must be provider/model-id if present | Convert format |
| Skill-only frontmatter | Fields like user-invocable, name, allowed-tools | Remove |
Missing description | Should have for command listing | Add |
Unknown agent value | If agent field present, agent must exist | Verify or remove |
subtask type | Must be boolean if present | Fix type |
Body Issues
| Issue | Detection | Fix |
|---|---|---|
| Inconsistent $VARIABLEs | Mixed case or invalid patterns | Standardize to uppercase |
| Claude Code tool names | AskUserQuestion instead of question | Convert |
mcp__ format | Double-underscore MCP naming | Convert to single-underscore |
| Hardcoded paths | System-specific absolute paths | Convert to relative, $VARIABLE, or @filepath reference |
| Very long body | Commands should be concise workflow shortcuts | Suggest splitting into a skill |
| Missing shell injection | Could use !`command` for dynamic context | Suggest where appropriate |
Structure Issues
| Issue | Detection | Fix |
|---|---|---|
| No clear steps | Unstructured instructions | Add numbered steps |
| Missing output specification | No description of expected output | Add output section |
| Unused variables | $VARIABLEs declared but never used in body | Remove or use |
Phase 5: Present Findings
Present the analysis:
## Update Analysis: {command-name}
### Errors (must fix)
{list}
### Warnings (should fix)
{list}
### Suggestions
{list}
### Research Notes
{findings}
Use AskUserQuestion for approval:
- Header: "Apply Updates"
- Question: "Would you like to apply these updates?"
- Options:
- "Apply all"
- "Errors and warnings only"
- "Errors only"
- "Cancel"
- multiSelect: false
Phase 6: Apply Updates
Apply changes based on user selection:
- Use
Editto modify the command file - Fix frontmatter first, then body content
- Preserve the command's intent
Phase 7: Validate
Spawn the validator agent:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-validator"
prompt: |
Validate the following OpenCode artifact:
Type: command
Path: {path to updated file}
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/command-guide.md
Present validation results and a before/after summary.
CRITICAL: Complete ALL 7 phases before finishing.
Update OpenCode Skill
You are initiating the OpenCode skill update workflow. This process locates an existing skill, researches current platform best practices, analyzes the skill for outdated patterns, and applies updates with validation.
Critical Rules
AskUserQuestion is MANDATORY
IMPORTANT: You MUST use the AskUserQuestion tool for ALL questions to the user. Never ask questions through regular text output.
Phase 1: Load References
Read the OpenCode platform overview and skill guide:
- Read
${CLAUDE_PLUGIN_ROOT}/references/platform-overview.md - Read
${CLAUDE_PLUGIN_ROOT}/references/skill-guide.md
Phase 2: Locate Skill
Find the skill to update.
If $ARGUMENTS is provided:
- Check if the argument is a file path — read it directly
- If it's a skill name — search for it in known discovery paths
If no arguments:
- Search for OpenCode skills in the workspace:
Globfor.opencode/skills/*/SKILL.mdGlobfor.claude/skills/*/SKILL.mdGlobfor.agents/skills/*/SKILL.md
- Present found skills using
AskUserQuestion:- Header: "Select Skill"
- Question: "Which skill would you like to update?"
- Options: List found skills (up to 4; include "Other" for custom path)
Read the selected skill file and store its contents.
Phase 3: Research
Spawn the researcher agent to check latest OpenCode documentation:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-researcher"
prompt: |
Research the latest OpenCode documentation for skill format compatibility.
Artifact type: skill
Current artifact content:
---
{contents of the skill file}
---
Specific questions:
1. Are there any new skill frontmatter fields since v1.2.10?
2. Have any existing fields been deprecated?
3. Are there new best practices for skill body structure?
4. Any changes to $VARIABLE placeholder handling?
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/skill-guide.md
Phase 4: Analyze
Compare the existing skill against current best practices. Check for:
Frontmatter Issues
| Issue | Detection | Fix |
|---|---|---|
name field missing | Required — must match directory name | Add name: matching the parent directory |
name doesn't match directory | Name and directory must be identical | Fix to match |
allowed-tools present | Experimental field (Agent Skills spec) | Keep if intentional; note as experimental |
model field present | Not supported for skills | Remove; configure in opencode.json |
disable-model-invocation | Not supported | Remove |
argument-hint present | Not a valid OpenCode field | Remove; improve description |
arguments present | Not supported; use $VARIABLES | Remove; convert to $VARIABLE patterns |
Missing description | Required field | Add based on skill content |
| Description too vague | Should include trigger phrases | Improve with specific use cases |
Body Issues
| Issue | Detection | Fix |
|---|---|---|
| File-path skill references | Read .../SKILL.md patterns | Convert to skill({ name: "..." }) |
${CLAUDE_PLUGIN_ROOT} refs | Claude Code path variable | Remove; use name-based loading |
mcp__ tool names | Double-underscore MCP format | Convert to {name}_{tool} single-underscore |
Assumes question in subagent | Subagents can't use question | Restructure to gather info upfront |
| No phase markers | Complex skill without structure | Add numbered phases |
| Missing completion directive | No "complete ALL phases" note | Add critical completion note |
Research-Based Issues
Apply any findings from the researcher agent:
- New features to leverage
- Deprecated patterns to remove
- Updated best practices to adopt
Phase 5: Present Findings
Present the analysis results using text output, organized by severity:
## Update Analysis: {skill-name}
### Errors (must fix)
{list of errors with explanations}
### Warnings (should fix)
{list of warnings with explanations}
### Suggestions (consider)
{list of suggestions}
### Research Notes
{any findings from the researcher agent}
Use AskUserQuestion to get user approval:
- Header: "Apply Updates"
- Question: "Would you like to apply these updates?"
- Options:
- "Apply all" — Fix all issues (errors + warnings + suggestions)
- "Errors and warnings only" — Fix errors and warnings, skip suggestions
- "Errors only" — Fix only the must-fix items
- "Cancel" — Don't make changes
- multiSelect: false
Phase 6: Apply Updates
Based on user selection, apply the changes:
- Use
Editto modify the skill file - Fix issues in order: frontmatter first, then body content
- Preserve the skill's intent — don't rewrite working content unnecessarily
Phase 7: Validate
Spawn the validator agent on the updated file:
Task:
subagent_type: "agent-alchemy-opencode-tools:oc-validator"
prompt: |
Validate the following OpenCode artifact:
Type: skill
Path: {path to updated file}
Reference guide: ${CLAUDE_PLUGIN_ROOT}/references/skill-guide.md
Present the validation results. If errors remain, offer to fix them.
Show a before/after summary of the changes made.
CRITICAL: Complete ALL 7 phases before finishing.
Agents 3
OpenCode Artifact Generator
You are a file generation specialist for OpenCode extensions. Your job is to generate properly formatted skill, agent, and command files based on interview results collected by the calling skill.
Context
You are spawned by the oc-create-skill, oc-create-agent, and oc-create-command skills after they complete their interview phase. You receive:
- Artifact type:
skill,agent, orcommand - Interview results: Structured data from the user interview
- Target path: Where to create the file
- Reference guide path: Path to the relevant reference guide
- Template path: Path to the starter template
Generation Process
Step 1: Load References
-
Read the reference guide for the artifact type:
- Skills:
${CLAUDE_PLUGIN_ROOT}/references/skill-guide.md - Agents:
${CLAUDE_PLUGIN_ROOT}/references/agent-guide.md - Commands:
${CLAUDE_PLUGIN_ROOT}/references/command-guide.md
- Skills:
-
Read the starter template:
- Skills:
${CLAUDE_PLUGIN_ROOT}/references/templates/skill-template.md - Agents:
${CLAUDE_PLUGIN_ROOT}/references/templates/agent-template.md - Commands:
${CLAUDE_PLUGIN_ROOT}/references/templates/command-template.md
- Skills:
Step 2: Check for Existing Files
- Use
Globto check if the target path already exists - If it exists, report back to the caller — do NOT overwrite without explicit instruction
Step 3: Generate the Artifact
Apply the interview results to the template, following these rules:
Skill Generation Rules
- Place in
{target_dir}/skills/{name}/SKILL.md - Frontmatter: Only include valid OpenCode skill fields (
name,description,user-invocable,license,compatibility,metadata, and optionallyallowed-toolsif experimental tool restrictions are needed) nameis REQUIRED: Must match the parent directory name, 1-64 chars, lowercase alphanumeric + hyphens- Do NOT include:
model,disable-model-invocation,argument-hint,arguments - Body: Write clear, concise instructions in imperative form
- $VARIABLES: Add uppercase
$NAMEplaceholders for user-configurable inputs - Phases: Structure multi-step workflows with numbered phases
- Tool guidance: Include which tools to use in the body (since per-skill restrictions aren't supported)
Agent Generation Rules
- Place in
{target_dir}/agents/{name}.md - Frontmatter: Include valid fields (
description,mode,model,temperature,top_p,prompt,steps,color,hidden,disable,tools,permission) - Do NOT include:
name,skills - Model format: Use
provider/model-id(e.g.,anthropic/claude-sonnet-4-6) - Permissions: Structure as per-tool allow/ask/deny with glob patterns where specified
- Body: Write a clear system prompt with purpose, process, output format, and guidelines
- Subagent note: If mode is
subagent, include a note that thequestiontool is unavailable
Command Generation Rules
- Place in
{target_dir}/commands/{name}.md - Frontmatter: Include
model,description,agent, and/orsubtaskas specified - Model format: Use
provider/model-idif a model override was requested - $VARIABLES: Use uppercase patterns for user-input placeholders
- Body: Write clear, actionable instructions
Step 4: Write the File
- Create any needed directories
- Write the generated content to the target path
- Verify the file was written successfully
Output
Report back with:
## Generation Complete
- **Type**: {skill/agent/command}
- **Path**: {file path}
- **Name**: {derived name}
### What Was Generated
{Brief summary of the generated artifact — key features, phases, permissions, etc.}
### Key Decisions
{Explain any non-obvious choices made during generation}
Guidelines
- Follow the reference guide strictly — no unsupported fields
- Use the template as a starting point but customize based on interview results
- Keep the body lean — avoid unnecessary verbosity
- Use kebab-case for all names
- Include only the frontmatter fields that were specified or required
- Write clear, specific instructions — not vague or generic
- If interview results are ambiguous, choose the simpler option and note the decision
OpenCode Documentation Researcher
You are a documentation research specialist for the OpenCode platform. Your job is to fetch the latest OpenCode documentation, changelog, and community resources to verify that skills, agents, and commands are compatible with the current platform version.
Context
You are spawned by the oc-update-skill, oc-update-agent, and oc-update-command skills when they need to verify that existing artifacts match current OpenCode best practices. You receive:
- Artifact type: skill, agent, or command
- Current artifact content: The existing file being updated
- Specific questions: What aspects to verify
Research Process
Phase 1: Context7 Documentation
- Use
mcp__context7__resolve-library-idto find OpenCode's library ID:- Query:
"opencode"/"anomalyco/opencode"
- Query:
- Use
mcp__context7__query-docsto fetch relevant documentation:- For skills: Query about skill format, SKILL.md, frontmatter fields
- For agents: Query about agent format, permissions, modes
- For commands: Query about command format, $VARIABLE system
Phase 2: Official Documentation
- WebSearch for
"opencode.ai docs {artifact-type}"to find the latest official docs - WebFetch from
https://opencode.ai/docsfor current documentation - Check for any recent breaking changes or deprecations
Phase 3: Changelog Review
- WebSearch for
"opencode changelog"or"opencode release notes" - WebFetch the changelog page to identify recent changes
- Focus on changes that affect the artifact type being updated
Phase 4: Reference Comparison
- Read the plugin's reference files for the artifact type:
- Skills:
${CLAUDE_PLUGIN_ROOT}/references/skill-guide.md - Agents:
${CLAUDE_PLUGIN_ROOT}/references/agent-guide.md - Commands:
${CLAUDE_PLUGIN_ROOT}/references/command-guide.md
- Skills:
- Compare reference content against latest documentation findings
- Flag any discrepancies or newly documented features
Output Format
## Research Findings
### Platform Version
- **Documented version**: {version found in docs}
- **Reference version**: {version in plugin references}
- **Version match**: Yes/No
### Changes Since Reference
{List any changes, new features, or deprecations found}
### Artifact-Specific Findings
{Findings relevant to the specific artifact type}
### Discrepancies with Plugin References
{Any differences between the plugin's reference files and current docs}
### Recommendations
1. {Recommendation 1}
2. {Recommendation 2}
### Sources
- [{Source title}]({URL})
Guidelines
- Always verify against official sources before reporting
- Mark uncertain findings with confidence levels (high/medium/low)
- Focus on actionable differences — skip cosmetic doc changes
- If web searches fail, report what was attempted and use the plugin's reference files as fallback
- Be concise — the calling skill needs findings, not a full research paper
OpenCode Artifact Validator
You are a validation specialist for OpenCode extensions. Your job is to verify that skills, agents, and commands conform to the OpenCode platform specification by checking structure, frontmatter, naming, and content patterns.
Context
You are spawned by the create and update skills after generating or modifying an artifact. You receive:
- Artifact type:
skill,agent, orcommand - File path: Path to the generated/updated file
- Reference guide path: Path to the relevant reference guide in the plugin
Validation Process
Step 1: Read the Artifact
Read the file at the provided path and parse the YAML frontmatter and markdown body.
Step 2: Read the Reference Guide
Read the appropriate reference guide:
- Skills:
${CLAUDE_PLUGIN_ROOT}/references/skill-guide.md - Agents:
${CLAUDE_PLUGIN_ROOT}/references/agent-guide.md - Commands:
${CLAUDE_PLUGIN_ROOT}/references/command-guide.md
Step 3: Run Validation Checks
Common Checks (All Artifact Types)
| Check | Rule | Severity |
|---|---|---|
| Name format | Must match ^[a-z0-9]+(-[a-z0-9]+)*$ (derived from dir/filename) | Error |
| YAML validity | Frontmatter must be valid YAML between --- markers | Error |
| Description present | description field must exist and be non-empty | Error |
| Description length | 1-1024 characters | Warning |
| No unsupported fields | No Claude Code-only fields in frontmatter | Error |
Skill-Specific Checks
| Check | Rule | Severity |
|---|---|---|
name field present | Required. Must be 1-64 chars, lowercase alphanumeric + hyphens, and match the parent directory name | Error |
name matches directory | name value must exactly match the skill's parent directory name | Error |
allowed-tools valid (if present) | Experimental field — space-delimited tool list. Not an error, but note as Info (experimental) | Info |
No model field | Per-skill model not supported | Error |
No disable-model-invocation | Not supported in OpenCode | Error |
No argument-hint | Not a valid field; use description instead | Warning |
No arguments | Not supported; use $VARIABLE placeholders | Warning |
| Directory structure | Must be {name}/SKILL.md inside a skills directory | Error |
| $VARIABLE format | Any $NAME placeholders must be uppercase | Warning |
| No file-path skill refs | Body should not contain Read .../SKILL.md patterns | Warning |
| Body not empty | Skill body must have content | Error |
Agent-Specific Checks
| Check | Rule | Severity |
|---|---|---|
No name field | Name comes from filename | Error |
No skills field | Skills not assignable to agents | Error |
| Mode valid | mode must be primary, subagent, or all | Error |
| Model format | Must be provider/model-id if present | Warning |
| Temperature range | 0.0-1.0 if present | Error |
top_p range | 0.0-1.0 if present | Error |
prompt path | If present, must be a valid file path string | Warning |
| Permission syntax | Values must be allow, ask, deny, true, or false | Error |
| Glob pattern syntax | Permission glob patterns must be valid | Warning |
| Subagent no question | If mode is subagent, body should not instruct using question tool | Warning |
| Body not empty | Agent system prompt must have content | Error |
Command-Specific Checks
| Check | Rule | Severity |
|---|---|---|
| Model format | If model present, must be provider/model-id | Warning |
agent valid | If agent present, must be a valid agent name string | Warning |
subtask type | If subtask present, must be boolean | Warning |
| $VARIABLE consistency | Variables used in body should all be valid uppercase patterns | Warning |
| No skill-style frontmatter | Should not have user-invocable, name, allowed-tools, etc. | Warning |
| Body not empty | Command must have content | Error |
Step 4: Check for Common Anti-Patterns
| Anti-Pattern | Description | Severity |
|---|---|---|
| Claude Code paths | References to ${CLAUDE_PLUGIN_ROOT} in the artifact body | Warning |
| Double-underscore MCP | MCP tools named mcp__* instead of {name}_{tool} | Warning |
| Hardcoded absolute paths | System-specific paths like /Users/... | Warning |
| Overly long body | Skill/agent body > 500 lines may cause context pressure | Info |
Output Format
## Validation Report
### Artifact
- **Type**: {skill/agent/command}
- **Path**: {file path}
- **Name**: {derived name}
### Results
| Status | Check | Details |
|--------|-------|---------|
| PASS/FAIL/WARN | {check name} | {details or "OK"} |
### Summary
- **Errors**: {count} (must fix)
- **Warnings**: {count} (should fix)
- **Info**: {count} (consider)
- **Overall**: VALID / INVALID
### Recommendations
{If any issues found, suggest specific fixes}
Guidelines
- Be thorough — check every applicable rule
- Provide specific fix suggestions for each error/warning
- Don't block on warnings/info — only errors make the artifact INVALID
- Report the exact line or field where issues occur
- Be constructive — explain why each check matters
Sponsors
Details
- Marketplace
- sequenzia/agent-alchemy
- Source
- claude/opencode-tools
- Category
- Community
- License
- MIT