home / skills / athola / claude-night-market / qwen-delegation

qwen-delegation skill

/plugins/conjure/skills/qwen-delegation

This skill orchestrates Qwen CLI delegation using delegation-core for large-context, batch analysis, and authenticated quota-aware command execution.

npx playbooks add skill athola/claude-night-market --skill qwen-delegation

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
4.4 KB
---
name: qwen-delegation
description: Qwen CLI delegation workflow implementing delegation-core for Alibaba's
  Qwen models. Use when delegation-core selected Qwen, need Qwen's large context capabilities,
  batch processing required. Do not use when deciding which model to use (use delegation-core
  first), qwen CLI not installed.
category: delegation-implementation
tags:
- qwen
- cli
- delegation
- alibaba
- large-context
dependencies:
- delegation-core
tools:
- qwen-cli
- delegation-executor
usage_patterns:
- qwen-cli-integration
- large-context-analysis
- bulk-processing
complexity: intermediate
estimated_tokens: 600
progressive_loading: true
modules:
- modules/qwen-specifics.md
references:
- delegation-core/shared-shell-execution.md
---
## Table of Contents

- [Overview](#overview)
- [When to Use](#when-to-use)
- [Prerequisites](#prerequisites)
- [Delegation Flow](#delegation-flow)
- [Quick Start](#quick-start)
- [Using Shared Delegation Executor](#using-shared-delegation-executor)
- [Direct CLI Usage](#direct-cli-usage)
- [Save Output](#save-output)
- [Smart Delegation](#smart-delegation)
- [Shared Patterns](#shared-patterns)
- [Qwen-Specific Details](#qwen-specific-details)
- [Exit Criteria](#exit-criteria)


# Qwen CLI Delegation

## Overview

This skill implements `conjure:delegation-core` for the Qwen CLI using shared delegation patterns. It provides Qwen-specific authentication, quota management, and command construction.

## When To Use
- After `Skill(conjure:delegation-core)` determines Qwen is suitable
- When you need Qwen's large context window (100K+ tokens)
- For batch processing, summarization, or multi-file analysis
- If the `qwen` CLI is installed and configured

## When NOT To Use

- Deciding which model to use (use delegation-core
  first)
- Qwen CLI not installed
- Deciding which model to use (use delegation-core
  first)
- Qwen CLI not installed

## Prerequisites

**Installation:**
```bash
# Install Qwen CLI
pip install qwen-cli

# Verify installation
qwen --version

# Check authentication
qwen auth status

# Login if needed
qwen auth login

# Or set API key
export QWEN_API_KEY="your-key"
```
**Verification:** Run `python --version` to verify Python environment.

## Delegation Flow

Implements standard delegation-core flow with Qwen specifics:

1. `qwen-delegation:auth-verified` - Verify Qwen authentication
2. `qwen-delegation:quota-checked` - Check Qwen API quota
3. `qwen-delegation:command-executed` - Execute via Qwen CLI
4. `qwen-delegation:usage-logged` - Log Qwen API usage

## Quick Start

### Using Shared Delegation Executor
```bash
# Basic file analysis
python ~/conjure/tools/delegation_executor.py qwen "Analyze this code" --files src/main.py

# With specific model
python ~/conjure/tools/delegation_executor.py qwen "Summarize" --files src/**/*.py --model qwen-max

# With output format
python ~/conjure/tools/delegation_executor.py qwen "Extract functions" --files src/main.py --format json
```
**Verification:** Run `python --version` to verify Python environment.

### Direct CLI Usage
```bash
# Basic command
qwen -p "@path/to/file Analyze this code"

# Multiple files
qwen -p "@src/**/*.py Summarize these files"

# Specific model
qwen --model qwen-max -p "..."
```
**Verification:** Run the command with `--help` flag to verify availability.

### Save Output
```bash
qwen -p "..." > delegations/qwen/$(date +%Y%m%d_%H%M%S).md
```
**Verification:** Run the command with `--help` flag to verify availability.

## Smart Delegation

The shared delegation executor can auto-select the best service:
```bash
# Auto-select based on requirements
python ~/conjure/tools/delegation_executor.py auto "Analyze large codebase" \
  --files src/**/* --requirement large_context
```
**Verification:** Run `python --version` to verify Python environment.

## Shared Patterns

This skill uses shared infrastructure from delegation-core:
- **Shell Execution**: See `delegation-core/shared-shell-execution.md`
- **Authentication**: Standard CLI authentication patterns
- **Quota Management**: Unified quota tracking
- **Usage Logging**: Centralized usage analytics

## Qwen-Specific Details

For Qwen-specific models, CLI options, cost reference, and troubleshooting, see `modules/qwen-specifics.md`.

## Exit Criteria
- Authentication confirmed working
- Quota checked and sufficient
- Command executed successfully using shared infrastructure
- Usage logged for tracking with unified analytics

Overview

This skill implements a Qwen CLI delegation workflow that plugs into the delegation-core patterns. It provides Qwen-specific authentication checks, quota verification, command construction, and usage logging to enable large-context or batch tasks with Qwen models. Use it when delegation-core has selected Qwen and the qwen CLI is installed and configured.

How this skill works

The skill verifies Qwen authentication and available quota, then builds and runs qwen CLI commands (single or batched) using shared delegation execution logic. It supports selecting Qwen models, large-context processing, file globs, and output formatting, and logs API usage to the shared analytics system. When needed, the shared executor can auto-select Qwen based on requirements like large_context or batch processing.

When to use it

  • After delegation-core selects Qwen as the target service
  • When you need Qwen’s very large context window (100k+ tokens)
  • For batch processing, multi-file analysis, or large summarization jobs
  • When the qwen CLI is installed and authenticated on the host
  • When you want unified quota checks and centralized usage logging

Best practices

  • Confirm qwen CLI is installed and authenticated (qwen auth status / qwen auth login) before delegating
  • Use the shared delegation executor for consistent auth, quota, and logging behavior
  • Prefer file globs and the CLI’s -p path syntax for multi-file jobs to leverage batching
  • Select appropriate Qwen model flags explicitly (e.g., --model qwen-max) for cost and capacity control
  • Save outputs to timestamped files for traceability and reruns

Example use cases

  • Summarize a large codebase using Qwen’s large context model with a single delegation run
  • Batch-extract functions across many files and write results in JSON for downstream processing
  • Run multi-file static analysis or audit prompts that exceed other models’ context limits
  • Auto-select Qwen for tasks tagged large_context via the shared delegation executor
  • Log usage for billing and quota decisions while running repeated batch delegations

FAQ

What if qwen CLI is not installed?

Install and configure the qwen CLI or choose a different delegation target; this skill requires the qwen CLI to execute commands.

How does quota checking work?

The skill queries Qwen authentication status and quota via CLI patterns and aborts delegation if quota is insufficient, following delegation-core quota conventions.