@mmmbuto/qwen-code-termux 0.12.0-termux → 0.14.0-termux

package/bundled/qc-helper/docs/features/approval-mode.md

@@ -0,0 +1,263 @@
+# Approval Mode
+
+Qwen Code offers three distinct permission modes that allow you to flexibly control how AI interacts with your code and system based on task complexity and risk level.
+
+## Permission Modes Comparison
+
+| Mode           | File Editing                | Shell Commands              | Best For                                                                                               | Risk Level |
+| -------------- | --------------------------- | --------------------------- | ------------------------------------------------------------------------------------------------------ | ---------- |
+| **Plan**​      | ❌ Read-only analysis only  | ❌ Not executed             | • Code exploration <br>• Planning complex changes <br>• Safe code review                               | Lowest     |
+| **Default**​   | ✅ Manual approval required | ✅ Manual approval required | • New/unfamiliar codebases <br>• Critical systems <br>• Team collaboration <br>• Learning and teaching | Low        |
+| **Auto-Edit**​ | ✅ Auto-approved            | ❌ Manual approval required | • Daily development tasks <br>• Refactoring and code improvements <br>• Safe automation                | Medium     |
+| **YOLO**​      | ✅ Auto-approved            | ✅ Auto-approved            | • Trusted personal projects <br>• Automated scripts/CI/CD <br>• Batch processing tasks                 | Highest    |
+
+### Quick Reference Guide
+
+- **Start in Plan Mode**: Great for understanding before making changes
+- **Work in Default Mode**: The balanced choice for most development work
+- **Switch to Auto-Edit**: When you're making lots of safe code changes
+- **Use YOLO sparingly**: Only for trusted automation in controlled environments
+
+> [!tip]
+>
+> You can quickly cycle through modes during a session using **Shift+Tab** (or **Tab** on Windows). The terminal status bar shows your current mode, so you always know what permissions Qwen Code has.
+
+## 1. Use Plan Mode for safe code analysis
+
+Plan Mode instructs Qwen Code to create a plan by analyzing the codebase with **read-only** operations, perfect for exploring codebases, planning complex changes, or reviewing code safely.
+
+### When to use Plan Mode
+
+- **Multi-step implementation**: When your feature requires making edits to many files
+- **Code exploration**: When you want to research the codebase thoroughly before changing anything
+- **Interactive development**: When you want to iterate on the direction with Qwen Code
+
+### How to use Plan Mode
+
+**Turn on Plan Mode during a session**
+
+You can switch into Plan Mode during a session using **Shift+Tab** (or **Tab** on Windows) to cycle through permission modes.
+
+If you are in Normal Mode, **Shift+Tab** (or **Tab** on Windows) first switches into `auto-edits` Mode, indicated by `⏵⏵ accept edits on` at the bottom of the terminal. A subsequent **Shift+Tab** (or **Tab** on Windows) will switch into Plan Mode, indicated by `⏸ plan mode`.
+
+**Start a new session in Plan Mode**
+
+To start a new session in Plan Mode, use the `/approval-mode` then select `plan`
+
+```bash
+/approval-mode
+```
+
+**Run "headless" queries in Plan Mode**
+
+You can also run a query in Plan Mode directly with `-p` or `prompt`:
+
+```bash
+qwen --prompt "What is machine learning?"
+```
+
+### Example: Planning a complex refactor
+
+```bash
+/approval-mode plan
+```
+
+```
+I need to refactor our authentication system to use OAuth2. Create a detailed migration plan.
+```
+
+Qwen Code analyzes the current implementation and create a comprehensive plan. Refine with follow-ups:
+
+```
+What about backward compatibility?
+How should we handle database migration?
+```
+
+### Configure Plan Mode as default
+
+```json
+// .qwen/settings.json
+{
+  "permissions": {
+    "defaultMode": "plan"
+  }
+}
+```
+
+## 2. Use Default Mode for Controlled Interaction
+
+Default Mode is the standard way to work with Qwen Code. In this mode, you maintain full control over all potentially risky operations - Qwen Code will ask for your approval before making any file changes or executing shell commands.
+
+### When to use Default Mode
+
+- **New to a codebase**: When you're exploring an unfamiliar project and want to be extra cautious
+- **Critical systems**: When working on production code, infrastructure, or sensitive data
+- **Learning and teaching**: When you want to understand each step Qwen Code is taking
+- **Team collaboration**: When multiple people are working on the same codebase
+- **Complex operations**: When the changes involve multiple files or complex logic
+
+### How to use Default Mode
+
+**Turn on Default Mode during a session**
+
+You can switch into Default Mode during a session using **Shift+Tab**​ (or **Tab** on Windows) to cycle through permission modes. If you're in any other mode, pressing **Shift+Tab** (or **Tab** on Windows) will eventually cycle back to Default Mode, indicated by the absence of any mode indicator at the bottom of the terminal.
+
+**Start a new session in Default Mode**
+
+Default Mode is the initial mode when you start Qwen Code. If you've changed modes and want to return to Default Mode, use:
+
+```
+/approval-mode default
+```
+
+**Run "headless" queries in Default Mode**
+
+When running headless commands, Default Mode is the default behavior. You can explicitly specify it with:
+
+```
+qwen --prompt "Analyze this code for potential bugs"
+```
+
+### Example: Safely implementing a feature
+
+```
+/approval-mode default
+```
+
+```
+I need to add user profile pictures to our application. The pictures should be stored in an S3 bucket and the URLs saved in the database.
+```
+
+Qwen Code will analyze your codebase and propose a plan. It will then ask for approval before:
+
+1. Creating new files (controllers, models, migrations)
+2. Modifying existing files (adding new columns, updating APIs)
+3. Running any shell commands (database migrations, dependency installation)
+
+You can review each proposed change and approve or reject it individually.
+
+### Configure Default Mode as default
+
+```bash
+// .qwen/settings.json
+{
+  "permissions": {
+"defaultMode": "default"
+  }
+}
+```
+
+## 3. Auto Edits Mode
+
+Auto-Edit Mode instructs Qwen Code to automatically approve file edits while requiring manual approval for shell commands, ideal for accelerating development workflows while maintaining system safety.
+
+### When to use Auto-Accept Edits Mode
+
+- **Daily development**: Ideal for most coding tasks
+- **Safe automation**: Allows AI to modify code while preventing accidental execution of dangerous commands
+- **Team collaboration**: Use in shared projects to avoid unintended impacts on others
+
+### How to switch to this mode
+
+```
+# Switch via command
+/approval-mode auto-edit
+
+# Or use keyboard shortcut
+Shift+Tab (or Tab on Windows) # Switch from other modes
+```
+
+### Workflow Example
+
+1. You ask Qwen Code to refactor a function
+2. AI analyzes the code and proposes changes
+3. **Automatically**​ applies all file changes without confirmation
+4. If tests need to be run, it will **request approval**​ to execute `npm test`
+
+## 4. YOLO Mode - Full Automation
+
+YOLO Mode grants Qwen Code the highest permissions, automatically approving all tool calls including file editing and shell commands.
+
+### When to use YOLO Mode
+
+- **Automated scripts**: Running predefined automated tasks
+- **CI/CD pipelines**: Automated execution in controlled environments
+- **Personal projects**: Rapid iteration in fully trusted environments
+- **Batch processing**: Tasks requiring multi-step command chains
+
+> [!warning]
+>
+> **Use YOLO Mode with caution**: AI can execute any command with your terminal permissions. Ensure:
+>
+> 1. You trust the current codebase
+> 2. You understand all actions AI will perform
+> 3. Important files are backed up or committed to version control
+
+### How to enable YOLO Mode
+
+```
+# Temporarily enable (current session only)
+/approval-mode yolo
+
+# Set as project default
+/approval-mode yolo --project
+
+# Set as user global default
+/approval-mode yolo --user
+```
+
+### Configuration Example
+
+```bash
+// .qwen/settings.json
+{
+  "permissions": {
+"defaultMode": "yolo",
+"confirmShellCommands": false,
+"confirmFileEdits": false
+  }
+}
+```
+
+### Automated Workflow Example
+
+```bash
+# Fully automated refactoring task
+qwen --prompt "Run the test suite, fix all failing tests, then commit changes"
+
+# Without human intervention, AI will:
+# 1. Run test commands (auto-approved)
+# 2. Fix failed test cases (auto-edit files)
+# 3. Execute git commit (auto-approved)
+```
+
+## Mode Switching & Configuration
+
+### Keyboard Shortcut Switching
+
+During a Qwen Code session, use **Shift+Tab**​ (or **Tab** on Windows) to quickly cycle through the three modes:
+
+```
+Default Mode → Auto-Edit Mode → YOLO Mode → Plan Mode → Default Mode
+```
+
+### Persistent Configuration
+
+```
+// Project-level: ./.qwen/settings.json
+// User-level: ~/.qwen/settings.json
+{
+  "permissions": {
+"defaultMode": "auto-edit",  // or "plan" or "yolo"
+"confirmShellCommands": true,
+"confirmFileEdits": true
+  }
+}
+```
+
+### Mode Usage Recommendations
+
+1. **New to codebase**: Start with **Plan Mode**​ for safe exploration
+2. **Daily development tasks**: Use **Auto-Accept Edits**​ (default mode), efficient and safe
+3. **Automated scripts**: Use **YOLO Mode**​ in controlled environments for full automation
+4. **Complex refactoring**: Use **Plan Mode**​ first for detailed planning, then switch to appropriate mode for execution

package/bundled/qc-helper/docs/features/arena.md

@@ -0,0 +1,218 @@
+# Agent Arena
+
+> Dispatch multiple AI models simultaneously to execute the same task, compare their solutions side-by-side, and select the best result to apply to your workspace.
+
+> [!warning]
+> Agent Arena is experimental. It has [known limitations](#limitations) around display modes and session management.
+
+Agent Arena lets you pit multiple AI models against each other on the same task. Each model runs as a fully independent agent in its own isolated Git worktree, so file operations never interfere. When all agents finish, you compare results and select a winner to merge back into your main workspace.
+
+Unlike [subagents](/users/features/sub-agents), which delegate focused subtasks within a single session, Arena agents are complete, top-level agent instances — each with its own model, context window, and full tool access.
+
+This page covers:
+
+- [When to use Agent Arena](#when-to-use-agent-arena)
+- [Starting an arena session](#start-an-arena-session)
+- [Interacting with agents](#interact-with-agents), including display modes and navigation
+- [Comparing results and selecting a winner](#compare-results-and-select-a-winner)
+- [Best practices](#best-practices)
+
+## When to use Agent Arena
+
+Agent Arena is most effective when you want to **evaluate or compare** how different models tackle the same problem. The strongest use cases are:
+
+- **Model benchmarking**: Evaluate different models' capabilities on real tasks in your actual codebase, not synthetic benchmarks
+- **Best-of-N selection**: Get multiple independent solutions and pick the best implementation
+- **Exploring approaches**: See how different models reason about and solve the same problem — useful for learning and insight
+- **Risk reduction**: For critical changes, validate that multiple models converge on a similar approach before committing
+
+Agent Arena uses significantly more tokens than a single session (each agent has its own context window and model calls). It works best when the value of comparison justifies the cost. For routine tasks where you trust your default model, a single session is more efficient.
+
+## Start an arena session
+
+Use the `/arena` slash command to launch a session. Specify the models you want to compete and the task:
+
+```
+/arena --models qwen3.5-plus,glm-5,kimi-k2.5 "Refactor the authentication module to use JWT tokens"
+```
+
+If you omit `--models`, an interactive model selection dialog appears, letting you pick from your configured providers.
+
+### What happens when you start
+
+1. **Worktree setup**: Qwen Code creates isolated Git worktrees for each agent at `~/.qwen/arena/<session-id>/worktrees/<model-name>/`. Each worktree mirrors your current working directory state exactly — including staged changes, unstaged changes, and untracked files.
+2. **Agent spawning**: Each agent starts in its own worktree with full tool access and its configured model. Agents are launched sequentially but execute in parallel.
+3. **Execution**: All agents work on the task independently with no shared state or communication. You can monitor their progress and interact with any of them.
+4. **Completion**: When all agents finish (or fail), you enter the result comparison phase.
+
+## Interact with agents
+
+### Display modes
+
+Agent Arena currently supports **in-process mode**, where all agents run asynchronously within the same terminal process. A tab bar at the bottom of the terminal lets you switch between agents.
+
+> [!note]
+> **Split-pane display modes are planned for the future.** We intend to support tmux-based and iTerm2-based split-pane layouts, where each agent gets its own terminal pane for true side-by-side viewing. Currently, only in-process tab switching is available.
+
+### Navigate between agents
+
+In in-process mode, use keyboard shortcuts to switch between agent views:
+
+| Shortcut | Action                            |
+| :------- | :-------------------------------- |
+| `Right`  | Switch to the next agent tab      |
+| `Left`   | Switch to the previous agent tab  |
+| `Up`     | Switch focus to the input box     |
+| `Down`   | Switch focus to the agent tab bar |
+
+The tab bar shows each agent's current status:
+
+| Indicator | Meaning                |
+| :-------- | :--------------------- |
+| `●`       | Running or idle        |
+| `✓`       | Completed successfully |
+| `✗`       | Failed                 |
+| `○`       | Cancelled              |
+
+### Interact with individual agents
+
+When viewing an agent's tab, you can:
+
+- **Send messages** — type in the input area to give the agent additional instructions
+- **Approve tool calls** — if an agent requests tool approval, the confirmation dialog appears in its tab
+- **View full history** — scroll through the agent's complete conversation, including model output, tool calls, and results
+
+Each agent is a full, independent session. Anything you can do with the main agent, you can do with an arena agent.
+
+## Compare results and select a winner
+
+When all agents complete, the Arena enters the result comparison phase. You'll see:
+
+- **Status summary**: Which agents succeeded, failed, or were cancelled
+- **Execution metrics**: Duration, rounds of reasoning, token usage, and tool call counts for each agent
+
+A selection dialog presents the successful agents. Choose one to apply its changes to your main workspace, or discard all results.
+
+### What happens when you select a winner
+
+1. The winning agent's changes are extracted as a diff against the baseline
+2. The diff is applied to your main working directory
+3. All worktrees and temporary branches are cleaned up automatically
+
+If you want to inspect results before deciding, each agent's full conversation history is available via the tab bar while the selection dialog is active.
+
+## Configuration
+
+Arena behavior can be customized in [settings.json](/users/configuration/settings):
+
+```json
+{
+  "arena": {
+    "worktreeBaseDir": "~/.qwen/arena",
+    "maxRoundsPerAgent": 50,
+    "timeoutSeconds": 600
+  }
+}
+```
+
+| Setting                   | Description                        | Default         |
+| :------------------------ | :--------------------------------- | :-------------- |
+| `arena.worktreeBaseDir`   | Base directory for arena worktrees | `~/.qwen/arena` |
+| `arena.maxRoundsPerAgent` | Maximum reasoning rounds per agent | `50`            |
+| `arena.timeoutSeconds`    | Timeout for each agent in seconds  | `600`           |
+
+## Best practices
+
+### Choose models that complement each other
+
+Arena is most valuable when you compare models with meaningfully different strengths. For example:
+
+```
+/arena --models qwen3.5-plus,glm-5,kimi-k2.5 "Optimize the database query layer"
+```
+
+Comparing three versions of the same model family yields less insight than comparing across providers.
+
+### Keep tasks self-contained
+
+Arena agents work independently with no communication. Tasks should be fully describable in the prompt without requiring back-and-forth:
+
+**Good**: "Refactor the payment module to use the strategy pattern. Update all tests."
+
+**Less effective**: "Let's discuss how to improve the payment module" — this benefits from conversation, which is better suited to a single session.
+
+### Limit the number of agents
+
+Up to 5 agents can run simultaneously. In practice, 2-3 agents provide the best balance of comparison value to resource cost. More agents means:
+
+- Higher token costs (each agent has its own context window)
+- Longer total execution time
+- More results to compare
+
+Start with 2-3 and scale up only when the comparison value justifies it.
+
+### Use Arena for high-impact decisions
+
+Arena shines when the stakes justify running multiple models:
+
+- Choosing an architecture for a new module
+- Selecting an approach for a complex refactor
+- Validating a critical bug fix from multiple angles
+
+For routine changes like renaming a variable or updating a config file, a single session is faster and cheaper.
+
+## Troubleshooting
+
+### Agents failing to start
+
+- Verify that each model in `--models` is properly configured with valid API credentials
+- Check that your working directory is a Git repository (worktrees require Git)
+- Ensure you have write access to the worktree base directory (`~/.qwen/arena/` by default)
+
+### Worktree creation fails
+
+- Run `git worktree list` to check for stale worktrees from previous sessions
+- Clean up stale worktrees with `git worktree prune`
+- Ensure your Git version supports worktrees (`git --version`, requires Git 2.5+)
+
+### Agent takes too long
+
+- Increase the timeout: set `arena.timeoutSeconds` in settings
+- Reduce task complexity — Arena tasks should be focused and well-defined
+- Lower `arena.maxRoundsPerAgent` if agents are spending too many rounds
+
+### Applying winner fails
+
+- Check for uncommitted changes in your main working directory that might conflict
+- The diff is applied as a patch — merge conflicts are possible if your working directory changed during the session
+
+## Limitations
+
+Agent Arena is experimental. Current limitations:
+
+- **In-process mode only**: Split-pane display via tmux or iTerm2 is not yet available. All agents run within a single terminal window with tab switching.
+- **No diff preview before selection**: You can view each agent's conversation history, but there is no unified diff viewer to compare solutions side-by-side before picking a winner.
+- **No worktree retention**: Worktrees are always cleaned up after selection. There is no option to preserve them for further inspection.
+- **No session resumption**: Arena sessions cannot be resumed after exiting. If you close the terminal mid-session, worktrees remain on disk and must be cleaned up manually via `git worktree prune`.
+- **Maximum 5 agents**: The hard limit of 5 concurrent agents cannot be changed.
+- **Git repository required**: Arena requires a Git repository for worktree isolation. It cannot be used in non-Git directories.
+
+## Comparison with other multi-agent modes
+
+Agent Arena is one of several planned multi-agent modes in Qwen Code. **Agent Team** and **Agent Swarm** are not yet implemented — the table below describes their intended design for reference.
+
+|                   | **Agent Arena**                                        | **Agent Team** (planned)                           | **Agent Swarm** (planned)                                |
+| :---------------- | :----------------------------------------------------- | :------------------------------------------------- | :------------------------------------------------------- |
+| **Goal**          | Competitive: Find the best solution to the _same_ task | Collaborative: Tackle _different_ aspects together | Batch parallel: Dynamically spawn workers for bulk tasks |
+| **Agents**        | Pre-configured models compete independently            | Teammates collaborate with assigned roles          | Workers spawned on-the-fly, destroyed on completion      |
+| **Communication** | No inter-agent communication                           | Direct peer-to-peer messaging                      | One-way: results aggregated by parent                    |
+| **Isolation**     | Full: separate Git worktrees                           | Independent sessions with shared task list         | Lightweight ephemeral context per worker                 |
+| **Output**        | One selected solution applied to workspace             | Synthesized results from multiple perspectives     | Aggregated results from parallel processing              |
+| **Best for**      | Benchmarking, choosing between model approaches        | Research, complex collaboration, cross-layer work  | Batch operations, data processing, map-reduce tasks      |
+
+## Next steps
+
+Explore related approaches for parallel and delegated work:
+
+- **Lightweight delegation**: [Subagents](/users/features/sub-agents) handle focused subtasks within your session — better when you don't need model comparison
+- **Manual parallel sessions**: Run multiple Qwen Code sessions yourself in separate terminals with [Git worktrees](https://git-scm.com/docs/git-worktree) for full manual control

package/bundled/qc-helper/docs/features/channels/_meta.ts

@@ -0,0 +1,7 @@
+export default {
+  overview: 'Overview',
+  telegram: 'Telegram',
+  weixin: 'WeChat',
+  dingtalk: 'DingTalk',
+  plugins: 'Plugins',
+};

package/bundled/qc-helper/docs/features/channels/dingtalk.md

@@ -0,0 +1,134 @@
+# DingTalk (Dingtalk)
+
+This guide covers setting up a Qwen Code channel on DingTalk (钉钉).
+
+## Prerequisites
+
+- A DingTalk organization account
+- A DingTalk bot application with AppKey and AppSecret (see below)
+
+## Creating a Bot
+
+1. Go to the [DingTalk Developer Portal](https://open-dev.dingtalk.com)
+2. Create a new application (or use an existing one)
+3. Under the application, enable the **Robot** capability
+4. In Robot settings, enable **Stream Mode** (机器人协议 → Stream 模式)
+5. Note the **AppKey** (Client ID) and **AppSecret** (Client Secret) from the application credentials page
+
+### Stream Mode
+
+DingTalk Stream mode uses an outbound WebSocket connection — no public URL or server is needed. The bot connects to DingTalk's servers, which push messages through the WebSocket. This is the simplest deployment model.
+
+## Configuration
+
+Add the channel to `~/.qwen/settings.json`:
+
+```json
+{
+  "channels": {
+    "my-dingtalk": {
+      "type": "dingtalk",
+      "clientId": "$DINGTALK_CLIENT_ID",
+      "clientSecret": "$DINGTALK_CLIENT_SECRET",
+      "senderPolicy": "open",
+      "sessionScope": "user",
+      "cwd": "/path/to/your/project",
+      "instructions": "You are a concise coding assistant responding via DingTalk.",
+      "groupPolicy": "open",
+      "groups": {
+        "*": { "requireMention": true }
+      }
+    }
+  }
+}
+```
+
+Set the credentials as environment variables:
+
+```bash
+export DINGTALK_CLIENT_ID=<your-app-key>
+export DINGTALK_CLIENT_SECRET=<your-app-secret>
+```
+
+Or define them in the `env` section of `settings.json`:
+
+```json
+{
+  "env": {
+    "DINGTALK_CLIENT_ID": "your-app-key",
+    "DINGTALK_CLIENT_SECRET": "your-app-secret"
+  }
+}
+```
+
+## Running
+
+```bash
+# Start only the DingTalk channel
+qwen channel start my-dingtalk
+
+# Or start all configured channels together
+qwen channel start
+```
+
+Open DingTalk and send a message to the bot. You should see a 👀 emoji reaction appear while the agent processes, followed by the response.
+
+## Group Chats
+
+DingTalk bots work in both DM and group conversations. To enable group support:
+
+1. Set `groupPolicy` to `"allowlist"` or `"open"` in your channel config
+2. Add the bot to a DingTalk group
+3. @mention the bot in the group to trigger a response
+
+By default, the bot requires an @mention in group chats (`requireMention: true`). Set `"requireMention": false` for a specific group to make it respond to all messages. See [Group Chats](./overview#group-chats) for full details.
+
+### Finding a Group's Conversation ID
+
+DingTalk uses `conversationId` to identify groups. You can find it in the channel service logs when someone sends a message in the group — look for the `conversationId` field in the log output.
+
+## Images and Files
+
+You can send photos and documents to the bot, not just text.
+
+**Photos:** Send an image (screenshot, diagram, etc.) and the agent will analyze it using its vision capabilities. This requires a multimodal model — add `"model": "qwen3.5-plus"` (or another vision-capable model) to your channel config. DingTalk supports sending images directly or as part of rich text messages (mixed text + images).
+
+**Files:** Send a PDF, code file, or any document. The bot downloads it from DingTalk's servers and saves it locally so the agent can read it with its file tools. Audio and video files are also supported. This works with any model.
+
+## Key Differences from Telegram
+
+- **Authentication:** AppKey + AppSecret instead of a static bot token. The SDK manages access token refresh automatically.
+- **Connection:** WebSocket stream instead of polling — no public IP or webhook URL needed.
+- **Formatting:** Responses use DingTalk's markdown dialect (a limited subset). Tables are automatically converted to plain text since DingTalk doesn't render them. Long messages are split into chunks at ~3800 characters.
+- **Working indicator:** A 👀 emoji reaction is added to the user's message while processing, then removed when the response is sent.
+- **Media download:** Two-step process — a `downloadCode` from the message is exchanged for a temporary download URL via DingTalk's API.
+- **Groups:** DingTalk uses `isInAtList` for @mention detection instead of parsing message entities.
+
+## Tips
+
+- **Use DingTalk markdown-aware instructions** — DingTalk supports a limited markdown subset (headers, bold, links, code blocks, but not tables). Adding instructions like "Use DingTalk markdown. Avoid tables." helps the agent format responses correctly.
+- **Restrict access** — In an organization context, `senderPolicy: "open"` may be acceptable. For tighter control, use `"allowlist"` or `"pairing"`. See [DM Pairing](./overview#dm-pairing) for details.
+- **Referenced messages** — Quoting (replying to) a user message includes the quoted text as context for the agent. Quoting bot responses is not yet supported.
+
+## Troubleshooting
+
+### Bot doesn't connect
+
+- Verify your AppKey and AppSecret are correct
+- Check that the environment variables are set before running `qwen channel start`
+- Make sure **Stream Mode** is enabled in the bot's settings on the DingTalk Developer Portal
+- Check the terminal output for connection errors
+
+### Bot doesn't respond in groups
+
+- Check that `groupPolicy` is set to `"allowlist"` or `"open"` (default is `"disabled"`)
+- Make sure you @mention the bot in the group message
+- Verify the bot has been added to the group
+
+### "No sessionWebhook in message"
+
+This means DingTalk didn't include a reply endpoint in the message callback. This can happen if the bot's permissions are misconfigured. Check the bot's settings in the Developer Portal.
+
+### "Sorry, something went wrong processing your message"
+
+This usually means the agent encountered an error. Check the terminal output for details.