@qwen-code/qwen-code 0.22.3 → 0.23.0

package/README.md

@@ -135,6 +135,36 @@ If you know Claude Code, you already know Qwen Code — and then some. We've put
 | Daemon Mode — `qwen serve` (multi-client shared agent)             |     ✓     |      —      |
 | IM Channels (Telegram / DingTalk / WeChat / Feishu)                |     ✓     |      —      |
 
+## Qwen Code Evaluation
+
+### Evaluation Configuration
+
+| Configuration           | Value                                                                                               |
+| ----------------------- | --------------------------------------------------------------------------------------------------- |
+| Dataset                 | `princeton-nlp/SWE-bench_Verified`, 500 cases                                                       |
+| Runs                    | 3 trials per version, 1,500 jobs per version; 7 Qwen Code versions                                  |
+| Model                   | `Qwen 3.7 Max`                                                                                      |
+| Sampling                | `temperature=1`, `top_p=0.95`                                                                       |
+| Thinking / Reasoning    | `interleaved_thinking=true`, `thinking_type=adaptive`, `reasoning_effort=high`                      |
+| Context / Output Limits | `context_1m=true`, `model_context_length=1,000,000`, `max_tokens=64,000`, `model_max_tokens=65,535` |
+| Harness Limits          | `max_iterations=500`, `runtime_timeout_sec=7,200`, `agent_timeout_multiplier=3.0`                   |
+
+### Scores by Qwen Code Version
+
+| Version |  Avg Score | Pass Rate | pass@3 | pass^3 |
+| ------- | ---------: | --------: | -----: | -----: |
+| 0.0.14  | **77.80%** |     84.6% |  84.6% |  69.2% |
+| 0.1.0   | **76.73%** |     84.6% |  84.6% |  68.0% |
+| 0.5.0   | **76.60%** |     83.0% |  83.0% |  68.4% |
+| 0.10.0  | **76.47%** |     84.4% |  84.4% |  67.4% |
+| 0.15.0  | **77.67%** |     84.6% |  84.6% |  68.6% |
+| 0.19.0  | **76.40%** |     85.0% |  85.0% |  65.8% |
+| 0.22.0  | **77.33%** |     84.4% |  84.4% |  68.0% |
+
+### Avg Score Trend
+
+![Qwen Code version Avg Score trend](./.github/assets/qwen-code-avg-score-trend.svg)
+
 ## Ecosystem
 
 - [**Qwen Code Desktop**](https://github.com/QwenLM/qwen-code/releases/tag/desktop-latest) — Official desktop app for macOS, Windows, and Linux

package/bundled/computer-use/SKILL.md

@@ -3,227 +3,163 @@ name: computer-use
 description: Control local desktop applications through Computer Use for tasks that require reading or operating app UI. Prefer purpose-built connectors, APIs, or CLIs when available.
 ---
 
-## `node_repl` + `@qwen-code/cua-sdk` (Computer Use)
-
-- Use `node_repl` (JavaScript) for all Computer Use actions.
-- Do not use other technologies besides `node_repl` for computer interactions
-  unless specifically requested by the user. This includes AppleScript,
-  `osascript`, JXA, System Events, and synthesized input.
-- Prefer a dedicated plugin or skill when it can complete the task; use
-  Computer Use for app interactions that are not exposed through a more
-  specific interface.
-- Use only the typed `ComputerUse` API. Do not use a generic SDK `callTool`,
-  direct `CuaDriver` imports, or a Qwen global bridge.
-- `node_repl` state persists across calls.
-- Use `nodeRepl.write(...)` for text output. It takes a string, so wrap objects
-  with `JSON.stringify(...)`.
-
-## Install automatically
-
-Run `qwen mcp list` to check whether the `node-repl` server is configured. If it
-is not configured, run both commands yourself:
+# Computer Use with the CUA SDK
 
-```bash
-qwen mcp add --scope user node-repl npx -y @qwen-code/node-repl-mcp@0.1.1
-npm install --no-save --package-lock=false @qwen-code/cua-sdk@0.20.2
-```
+- Prefer a dedicated connector or API. Use Computer Use only for UI state or
+  interactions the dedicated interface does not expose.
+- Perform Computer Use through `node_repl` and the typed `ComputerUse` API.
+  Do not use generic `callTool`, direct driver imports, AppleScript, JXA, or
+  synthesized-input utilities.
+- Observe the exact current window before acting. Prefer current element tokens
+  over screenshot coordinates; use coordinates only when accessibility is
+  incomplete and the screenshot provides the target.
+- Treat an action result as delivery evidence, not task completion. Decide from
+  fresh state and require stable postcondition evidence.
 
-Tell the user to restart Qwen Code after adding the MCP server, then stop. Do
-not ask the user to copy or run the commands.
+## Setup
 
-If `node_repl` is available but the SDK import fails, run the SDK installation
-command yourself from the current workspace, then retry the import:
+If `node_repl` is unavailable, run these commands yourself:
 
 ```bash
-npm install --no-save --package-lock=false @qwen-code/cua-sdk@0.20.2
+qwen mcp add --scope user node-repl npx -y @qwen-code/node-repl-mcp@0.1.2
+npm install --no-save --package-lock=false @qwen-code/cua-sdk@0.20.3
 ```
 
-## Bootstrap
+Tell the user to restart Qwen Code, then stop. If only the SDK import is
+missing, run the second command and retry.
 
-Import the SDK once per fresh `node_repl` kernel:
+Create one persistent client per REPL kernel:
 
 ```js
 globalThis.computer = await (
   await import('@qwen-code/cua-sdk/computer-use')
 ).ComputerUse.create();
+globalThis.cuaRevisions ??= new Map();
 ```
 
-## API surface
-
-```ts
-type WindowTarget = { pid: number; windowId: number };
-type ElementTarget = {
-  pid: number;
-  windowId?: number;
-  elementToken: string;
-};
-type CoordinateTarget = WindowTarget & { x: number; y: number };
-type PointOrElementTarget = CoordinateTarget | ElementTarget;
-type App = {
-  name?: string;
-  bundle_id?: string;
-  pid?: number;
-  running?: boolean;
-  launch_path?: string;
-};
-type Window = {
-  window_id: number;
-  title?: string;
-  is_on_screen?: boolean;
-  on_current_space?: boolean;
-};
-type Element = {
-  element_token?: string;
-  role?: string;
-  label?: string;
-  value?: unknown;
-  actions?: string[];
-};
-
-type ComputerUse = {
-  listApps: () => Promise<App[]>;
-  listWindows: (args?: {
-    pid?: number;
-    onScreenOnly?: boolean;
-  }) => Promise<Window[]>;
-  observeWindow: (
-    args: WindowTarget & {
-      baseRevisionId?: string;
-      forceFull?: boolean;
-      includeScreenshot?: boolean;
-    },
-  ) => Promise<{
-    text: string;
-    elements: Element[];
-    revisionId?: string;
-    screenshot?: { images: object[] };
-  }>;
-  click: (
-    args: PointOrElementTarget & {
-      button?: 'left' | 'right' | 'middle';
-      count?: number;
-    },
-  ) => Promise<object>;
-  doubleClick: (args: PointOrElementTarget) => Promise<object>;
-  rightClick: (args: PointOrElementTarget) => Promise<object>;
-  setValue: (args: ElementTarget & { value: string }) => Promise<object>;
-  typeText: (args: WindowTarget & { text: string }) => Promise<object>;
-  pressKey: (args: WindowTarget & { key: string }) => Promise<object>;
-  hotkey: (args: WindowTarget & { keys: string[] }) => Promise<object>;
-  scroll: (
-    args: PointOrElementTarget & {
-      direction: 'up' | 'down' | 'left' | 'right';
-      by?: 'line' | 'page';
-      amount?: number;
-    },
-  ) => Promise<object>;
-  drag: (
-    args: WindowTarget & {
-      fromX: number;
-      fromY: number;
-      toX: number;
-      toY: number;
-      deliveryMode?: 'background' | 'foreground';
-    },
-  ) => Promise<object>;
-  performSecondaryAction: (
-    args: ElementTarget & { action: string },
-  ) => Promise<object>;
-  close: () => Promise<void>;
-};
-```
-
-## Workflow
+## Target and observe
 
-### 1. Initialize
+Use `listApps({signal:nodeRepl.signal})` and filter in JavaScript; print only
+likely matches. After selecting a real PID, call
+`listWindows({pid,signal:nodeRepl.signal})` and choose from returned
+metadata. Never guess a PID, window ID, element token, or coordinate. If the
+app is not running, start it with ordinary Node.js process APIs and refresh the
+lists.
 
-Resolve the exact running application and window named by the task. Filter
-inside `node_repl`; do not print the entire application list:
+Maintain one revision cursor per window surface. The first observation has no
+base; later observations use only the last revision actually consumed for that
+same surface:
 
 ```js
-var apps = await computer.listApps();
-var matches = apps.filter(
-  (app) => app.name === 'Target App' || app.bundle_id === 'com.example.target',
-);
-nodeRepl.write(JSON.stringify(matches));
+globalThis.observeCuaWindow = async (target, options = {}) => {
+  const key = `${target.pid}:${target.windowId}`;
+  const state = await computer.observeWindow({
+    ...target,
+    ...options,
+    baseRevisionId: cuaRevisions.get(key),
+    signal: nodeRepl.signal,
+  });
+  if (state.revisionId) cuaRevisions.set(key, state.revisionId);
+  return state;
+};
 ```
 
-After choosing the application from returned metadata, list only its windows:
+Use accessibility text for efficient decisions. Request a screenshot when the
+tree is incomplete, visual layout matters, or action evidence conflicts with
+the tree. Emit only decision-relevant images:
 
 ```js
-var pid = matches[0].pid;
-var windows = await computer.listWindows({ pid });
-nodeRepl.write(JSON.stringify(windows));
+for (const image of state.screenshot?.images ?? []) {
+  if (image?.dataBase64 && image?.mimeType) {
+    await nodeRepl.emitImage(
+      `data:${image.mimeType};base64,${image.dataBase64}`,
+    );
+  }
+}
 ```
 
-Choose the window from returned metadata, then get its current accessibility
-state:
-
-```js
-var target = { pid, windowId: windows[0].window_id };
-var state = await computer.observeWindow({ ...target, forceFull: true });
-nodeRepl.write(state.text);
-```
+If the SDK explicitly reports a missing/invalid base or a stale lineage,
+perform one observation with `forceFull: true`, replace that surface's cursor,
+then resume the normal helper. Do not make full observations the default.
 
-Never guess a PID, window ID, coordinate, or element token. `ComputerUse`
-discovers running applications but does not launch them; if necessary, start
-the application from `node_repl` with ordinary Node.js process APIs, then
-refresh the application and window lists.
+## Act and verify
 
-### 2. Act and get the latest state
+Choose the narrowest action supported by current state. Pass an observed
+`element_token` as `elementToken`. Use `performSecondaryAction` only when that
+exact action appears in the element's current `actions` list.
 
-Choose only the action needed for the user's task. Prefer current
-`element_token` values over coordinates. Pass an observed `element_token` as
-the camel-case `elementToken` action field:
+Before acting, state a concrete observable postcondition. For postconditions
+expressible as window or element state, use `actAndVerify` with `verifyState`:
 
 ```js
-await computer.setValue({
-  ...target,
-  elementToken,
-  value: 'hello',
-});
-
-state = await computer.observeWindow({
-  ...target,
-  baseRevisionId: state.revisionId,
-});
-nodeRepl.write(state.text);
+try {
+  globalThis.lastCuaOutcome = await computer.actAndVerify({
+    action: () =>
+      computer.setValue({
+        ...target,
+        elementToken,
+        value: expectedValue,
+        signal: nodeRepl.signal,
+      }),
+    verify: () =>
+      computer.verifyState({
+        ...target,
+        expect: [
+          {
+            element: {
+              selector: { role: expectedRole, label_contains: expectedLabel },
+              value_equals: expectedValue,
+            },
+          },
+        ],
+        stableSamples: 2,
+        signal: nodeRepl.signal,
+      }),
+  });
+  nodeRepl.write(JSON.stringify(lastCuaOutcome));
+} catch (error) {
+  nodeRepl.write(JSON.stringify(error?.details ?? { message: String(error) }));
+  throw error;
+}
 ```
 
-After one or more actions, always observe the exact window before deciding what
-to do next. If the updated state shows the requested result, stop acting,
-clean up, and answer the user. If the UI does not behave as expected, get a
-fresh full state before choosing a different action.
+`verifyState.expect` accepts one to eight AND-combined predicates:
 
-Use a secondary action only when the current accessibility state advertises
-that exact action. Prefer accessibility text for efficiency; use a screenshot
-when it is incomplete or visual layout matters.
+- `{window:{exists, bounds?}}`
+- `{element:{selector:{role?, label_contains?}, exists:true?,
+value_equals?, enabled?, selected?}}`
 
-## Reading screenshots
+Element absence is not provable. `unknown` and `stable:false` are not success.
+When the postcondition is visual or unsupported, observe the exact window
+again with a screenshot and inspect the fresh result before deciding. If state
+is unexpected, observe again rather than repeating the action blindly.
 
-```js
-var state = await computer.observeWindow({
-  ...target,
-  forceFull: true,
-  includeScreenshot: true,
-});
+Read every action result. `effect` is `confirmed`, `partial`, `unverifiable`,
+`suspected_noop`, or `refused`; `route`, `delivery`, `evidence`, `escalation`,
+and `operation` explain what actually happened. A committed operation can
+still have `cancellationRequested:true`, so it still requires verification.
+Follow an advertised escalation only after fresh state shows it is needed.
 
-for (var image of state.screenshot?.images ?? []) {
-  if (image?.dataBase64 && image?.mimeType) {
-    await nodeRepl.emitImage(
-      `data:${image.mimeType};base64,${image.dataBase64}`,
-    );
-  }
-}
-```
+## Interaction details
 
-## Finish
+- After navigation, dialogs, menus, or other surface changes, refresh the
+  relevant window list and observe the new exact surface.
+- Use returned state to determine text-field behavior; do not assume typing
+  replaces existing text. Use the platform-appropriate select-all action when
+  replacement is required.
+- Prefer background delivery. Use `deliveryMode:'foreground'` only when the
+  action result or fresh state shows the background route is unavailable or
+  ineffective.
+- Stop as soon as the requested postcondition is stably satisfied. Do not add
+  extra cleanup actions that could undo the result.
 
-When the task is complete, close the SDK client:
+## Finish
 
 ```js
 await computer.close();
 globalThis.computer = undefined;
+globalThis.cuaRevisions = undefined;
+globalThis.observeCuaWindow = undefined;
 ```
 
-Call `node_repl_reset` when no other REPL state is needed.
+Reset the REPL only when no other persistent state is needed.

package/bundled/goal-draft/SKILL.md

@@ -100,7 +100,11 @@ Check every line before printing:
 8. Under ~1200 characters.
 9. Irreversible actions (push, delete, publish) are listed in Must not, or the user explicitly allowed them.
 
-Then print, and nothing else:
+Then hand off, and nothing else:
+
+**If the `propose_goal` tool is available and no Goal is active**, call it with the objective on one line. The user approves or declines it in a dialog; only their approval sets the Goal. If they decline you will not be told why: stop, do not ask about it, and do not propose the same or a reworded objective again. After approval, acknowledge it in one sentence and end the turn — the Goal runtime starts the first Goal turn on its own.
+
+**Otherwise** (headless, the tool is disabled, or a Goal is active), print:
 
 1. The objective in a fenced code block.
 2. One line the user can run as-is: `/goal set <objective on one line>` (or `/goal edit …` when tightening the active goal). Print it as plain text with no code markers, so it can be copied verbatim.

package/bundled/qc-helper/docs/common-workflow.md

@@ -569,3 +569,35 @@ what are the limitations of Qwen Code?
 > - Qwen Code always has access to the latest Qwen Code documentation, regardless of the version you're using
 > - Ask specific questions to get detailed answers
 > - Qwen Code can explain complex features like MCP integration, enterprise configurations, and advanced workflows
+
+## Enforce evidence-based conclusions
+
+When Qwen Code does high-stakes work — code review, incident troubleshooting, audits, or investigating production data — a confident but wrong conclusion costs more than no conclusion at all. You can encode your team's verification policy in QWEN.md (see [Memory](./features/memory.md)) so it applies to every session, without changing anyone's defaults.
+
+The rules below are adapted from a production retrospective of a multi-agent deployment, where confident-but-wrong conclusions repeatedly traced back to the same failure modes: inferring state from code instead of querying it, treating one satisfied condition as proof, and repeating earlier statements as facts.
+
+**1. Add a verification policy to your project QWEN.md**
+
+Put this template in `QWEN.md` at your repository root and commit it, so the policy applies to the whole team:
+
+```markdown
+# Verification policy
+
+Treat these rules as mandatory in investigations, troubleshooting, reviews, and any task that draws conclusions:
+
+1. Verify before concluding. Back claims about data or system state with evidence from the authoritative source (database, API, logs, command output). Conclusions drawn from reading code alone must be labeled "unverified inference".
+2. Verify the full chain. Enumerate the causal chain and check every link; one satisfied necessary condition does not prove a conclusion.
+3. Treat conversation history as leads, not facts. Statements in earlier transcripts — including your own prior assertions — are leads. Re-verify them at the source before repeating them as facts.
+4. Troubleshoot in order: your own recent changes first, then docs and known issues, and only then external dependencies.
+5. 100% evidence rule in reviews. In review and audit tasks, report no conclusion without evidence; attach verifiable evidence (file:line, query result, log excerpt) to every claim.
+```
+
+**2. Choose the right scope**
+
+See [Where to create QWEN.md](./features/memory.md#where-to-create-qwenmd) for which file applies to whom — commit the project-root `QWEN.md` copy so the policy covers the whole team.
+
+> [!tip]
+>
+> - Keep the rules specific and actionable: "back every claim with a query result" works better than "be careful".
+> - Keep the policy short — QWEN.md is followed more reliably when it is concise (see [Memory](./features/memory.md)).
+> - Adapt the rules to your stack: name the actual query tools, dashboards, or log commands your team treats as authoritative sources.

package/bundled/qc-helper/docs/configuration/auth.md

@@ -157,12 +157,12 @@ The key concept is **Model Providers** (`modelProviders`): Qwen Code supports mu
 
 #### Supported protocols
 
-| Protocol          | `modelProviders` key | Environment variables                                                                                                                                                                                                                                                                                 | Providers                                                                                             |
-| ----------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
-| OpenAI-compatible | `openai`             | `OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_MODEL` (alias: `QWEN_MODEL`)                                                                                                                                                                                                                             | OpenAI, Azure OpenAI, OpenRouter, Requesty, ModelScope, Alibaba Cloud, any OpenAI-compatible endpoint |
-| Anthropic         | `anthropic`          | `ANTHROPIC_API_KEY`, `ANTHROPIC_BASE_URL`, `ANTHROPIC_MODEL`                                                                                                                                                                                                                                          | Anthropic Claude                                                                                      |
-| Google GenAI      | `gemini`             | `GEMINI_API_KEY`, `GEMINI_MODEL`                                                                                                                                                                                                                                                                      | Google Gemini                                                                                         |
-| Vertex AI         | `vertex-ai`          | `GOOGLE_API_KEY` or `GOOGLE_CLOUD_PROJECT` (+ optional `GOOGLE_CLOUD_LOCATION`), `GOOGLE_MODEL` (uses the `gemini` protocol; a keyless project-only setup is not auto-detected from the environment, so select the auth type explicitly with `--auth-type vertex-ai` or `security.auth.selectedType`) | Google Vertex AI                                                                                      |
+| Protocol          | `modelProviders` key | Environment variables                                                                                                                                          | Providers                                                                                             |
+| ----------------- | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| OpenAI-compatible | `openai`             | `OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_MODEL` (alias: `QWEN_MODEL`)                                                                                      | OpenAI, Azure OpenAI, OpenRouter, Requesty, ModelScope, Alibaba Cloud, any OpenAI-compatible endpoint |
+| Anthropic         | `anthropic`          | `ANTHROPIC_API_KEY`, `ANTHROPIC_BASE_URL`, `ANTHROPIC_MODEL`                                                                                                   | Anthropic Claude                                                                                      |
+| Google GenAI      | `gemini`             | `GEMINI_API_KEY`, `GEMINI_MODEL`                                                                                                                               | Google Gemini                                                                                         |
+| Vertex AI         | `vertex-ai`          | `GOOGLE_API_KEY` + `GOOGLE_MODEL` (sets `GOOGLE_GENAI_USE_VERTEXAI=true`) or `GOOGLE_CLOUD_PROJECT` + `GOOGLE_MODEL` (keyless ADC); uses the `gemini` protocol | Google Vertex AI                                                                                      |
 
 #### Step 1: Configure models and providers in `~/.qwen/settings.json`
 

package/bundled/qc-helper/docs/configuration/model-providers.md

@@ -18,6 +18,10 @@ Use `modelProviders` to declare models per provider id that the `/model` picker
 >
 > **Model uniqueness:** Models within the same `authType` are uniquely identified by the combination of `id` + `baseUrl`. This means you can define the same model ID (e.g., `"gpt-4o"`) multiple times under a single `authType` as long as each entry has a different `baseUrl` — for example, one pointing to OpenAI directly and another to a proxy endpoint. If two entries share both the same `id` and the same `baseUrl` (or both omit `baseUrl`), the first occurrence wins and subsequent duplicates are skipped with a warning.
 
+> [!note]
+>
+> **Hot reload vs. restart:** `modelProviders` edits in `settings.json` are picked up by a running interactive session without a restart (the file watcher debounces ~300ms; reopen `/model` to see new entries, the current selection is kept). `providerProtocol` is read once at startup and **requires a restart**.
+
 ### Image generation routes
 
 Set `supportsImageGeneration: true` when a route can be used by the built-in
@@ -469,9 +473,11 @@ Coding Plan model configurations are versioned. When Qwen Code detects a newer v
 
 - Replace the existing Coding Plan model configurations with the latest versions
 - Preserve any custom model configurations you've added manually
-- Automatically switch to the first model in the updated configuration
+- Leave your selected model unchanged; if it is no longer in the updated
+  configuration, use `/model` to choose a new one
 
-The update process ensures you always have access to the latest model configurations and features without manual intervention.
+The update process refreshes the model configurations and features without
+changing your selected model.
 
 ### Manual Configuration (Advanced)