… compat

Hardcoded Unix paths like '/tmp/custom-qwen/settings.json' fail on
Windows where path APIs produce backslash separators. Use path.resolve()
for inputs and path.join() for assertions so the tests pass cross-platform.

…opes' test

Timing-sensitive UI test that fails intermittently on Windows CI due to
async ANSI output not settling within the wait window.

…getGlobalQwenDir()

Update channel status, memory command, extension storage, skills
discovery, and memory discovery to use Storage.getGlobalQwenDir()
instead of hardcoded os.homedir()/.qwen paths, ensuring QWEN_CONFIG_DIR
env var is respected throughout the codebase.

…alQwenDir

Storage.getGlobalQwenDir() is now called during Config construction,
which requires os.homedir() to be mocked before makeFakeConfig() is
called. Also mock Storage.getGlobalQwenDir in memoryCommand tests
since it uses a cross-package import that vi.spyOn doesn't intercept.

findEnvFile() walk-up would find legacy ~/.qwen/.env before checking
QWEN_CONFIG_DIR/.env when the workspace was under $HOME. Skip the
legacy path when a custom config dir is set so the fallback picks up
the correct file.

Also add a legacy fallback in readSourceInfo() since the installer
always writes source.json to ~/.qwen/ regardless of QWEN_CONFIG_DIR.

…ath resolution

Rename the env var before it ships (zero existing users) to match the
convention of CARGO_HOME, GRADLE_USER_HOME, etc. — "HOME" means "root of
all tool state", not just config.

Key changes:
- Rename QWEN_CONFIG_DIR → QWEN_HOME across all packages and scripts
- Add shared path utils in vscode-ide-companion and channels/base to
  eliminate scattered inline env var resolution
- Fix runtime path mismatch: IDE lock files and session paths in the
  vscode extension now route through getRuntimeBaseDir() (checking
  QWEN_RUNTIME_DIR first), matching core Storage behavior
- Fix telemetry_utils.js otel path to check QWEN_RUNTIME_DIR for tmp/
- Add E2E integration tests for QWEN_HOME scenarios

Pass resolved QWEN_HOME as a dedicated QWEN_DIR sandbox parameter so
macOS Seatbelt profiles allow writes to custom config directories.
Fix hookRunner treating signal-killed hooks as success by using ?? -1
instead of || 0. Add QWEN_HOME and QWEN_RUNTIME_DIR to the env vars
documentation table.

When QWEN_RUNTIME_DIR is set separately from QWEN_HOME, the sandbox
was blocking writes to the runtime directory (debug logs, chat history,
IDE locks, sessions). Pass RUNTIME_DIR as a sandbox parameter and add
the corresponding subpath rule to all six .sb profiles.

…helpers

- Extract resolvePath() from resolveRuntimeBaseDir() so QWEN_HOME gets
  the same ~/tilde expansion that QWEN_RUNTIME_DIR already had.
- Port resolvePath() to vscode-ide-companion and channels/base mirrors,
  fixing tilde handling in getRuntimeBaseDir() for the IDE companion.
- Add missing os.tmpdir() fallback in channels/base getGlobalQwenDir().
- Add unit tests for tilde expansion in QWEN_HOME.
- Clarify prompts.ts comment that system.md default is global, not
  project-level.

…N_HOME support

Add resolvePath() helper to standalone JS scripts (sandbox_command.js,
telemetry.js, telemetry_utils.js) so QWEN_HOME=~/custom expands
consistently with core Storage.resolvePath().

Fix ExtensionManager.refreshCache() to use ExtensionStorage.getUserExtensionsDir()
instead of hardcoded os.homedir(), so extensions installed under a custom
QWEN_HOME are discoverable.

Resolve conflict in InputPrompt.test.tsx by keeping the branch's
deletion of two prompt suggestion tests (tab acceptance and shift+tab
rejection) that were still present on main.

…#3559)

params.pages !== undefined let "" fall through to parsePDFPageRange(''),
which returns null and surfaced "Invalid pages parameter: ''" for every
read_file call from models that default optional strings to "".

Switch to a truthy check so "" behaves the same as an omitted field, and
add a regression test.

Fixes QwenLM#3558

…QwenLM#3540)

* feat(session): auto-title sessions via fast model, add /rename --auto

The /rename work in QwenLM#3093 generates kebab-case titles only when the user
explicitly runs `/rename` with no args; until they do, the session picker
shows the first user prompt (often truncated or misleading). This change
adds a sentence-case auto-title that fires once per session after the
first assistant turn, using the configured fast model.

New service: `packages/core/src/services/sessionTitle.ts` —
`tryGenerateSessionTitle(config, signal)` returns a discriminated outcome
(`{ok: true, title, modelUsed}` | `{ok: false, reason}`) so callers can
either handle failures generically or map reasons to actionable messages.
Prompt shape: 3-7 words, sentence case, good/bad examples including a
CJK row, JSON schema enforced via `baseLlmClient.generateJson`.
`maxAttempts: 1` — titles are cosmetic metadata and shouldn't fight
rate limits.

Trigger point: `ChatRecordingService.maybeTriggerAutoTitle` runs after
`recordAssistantTurn`. Fire-and-forget promise, guarded by:

- `currentCustomTitle` — don't overwrite any existing title.
- `autoTitleController` doubles as in-flight flag; a second turn while
  the first is still pending is a no-op.
- `autoTitleAttempts` cap of 3 — the first assistant turn may be a
  pure tool-call with no user-visible text; retry for a handful of
  turns until a title lands. Cap bounds total waste.
- `!config.isInteractive()` — headless CLI (`qwen -p`, CI) never auto-
  titles; spending fast-model tokens on a one-shot session is waste.
- `autoTitleDisabledByEnv()` — `QWEN_DISABLE_AUTO_TITLE=1` opt-out.
- `config.getFastModel()` falsy — skip entirely rather than falling
  back to the main model; auto-titling on main-model tokens is too
  expensive to be silent.

Persistence: `CustomTitleRecordPayload` grows a `titleSource: 'auto' |
'manual'` field. Absent on pre-change records (treated as `undefined`
→ manual, safe default so a user's pre-upgrade `/rename` is never
silently reclassified). `SessionPicker` renders `titleSource === 'auto'`
titles in dim (secondary) color; manual stays full contrast. On resume,
the persisted source is rehydrated into `currentTitleSource` — without
this, finalize's re-append would rewrite an auto title as manual on
every resume cycle.

Cross-process manual-rename guard: when two CLI tabs target the same
JSONL, in-memory state can diverge. Before writing an auto record, the
IIFE re-reads the file via `sessionService.getSessionTitleInfo`. If a
`/rename` from another process landed as manual, bail and sync local
state — never clobber a deliberately-chosen manual title with a model
guess. Cost is one 64KB tail read per successful generation.

`finalize()` aborts the in-flight controller before re-appending the
title record. Session switch / shutdown doesn't have to wait on a slow
fast-model call.

New user-facing command: `/rename --auto` regenerates via the same
generator — explicit user trigger, overwrites whatever's there (manual
or auto) because the user asked. Errors route through
`autoFailureMessage(reason)` so `empty_history`, `model_error`,
`aborted`, etc. each get actionable guidance rather than a generic
"could not generate". `/rename -- --literal-name` is the sentinel for
titles that start with `--`; unknown `--flag` tokens error with a hint
pointing at the sentinel. Existing `/rename <name>` and bare `/rename`
(kebab-case via existing path) are unchanged, except the kebab path now
prefers fast model when available and runs its output through
`stripTerminalControlSequences` (same ANSI/OSC-8 hardening as the
sentence-case path).

New shared util: `packages/core/src/utils/terminalSafe.ts` —
`stripTerminalControlSequences(s)` strips OSC (\x1b]...\x07|\x1b\\), CSI
(\x1b[...[a-zA-Z]), SS2/SS3 leaders, and C0/C1/DEL as a backstop. A
model-returned `\x1b[2J` or OSC-8 hyperlink escape would otherwise
execute on every SessionPicker render; both sentence-case and kebab
paths now route titles through the helper before they reach the JSONL
or the UI.

Tail-read extractor: `extractLastJsonStringFields(text, primaryKey,
otherKeys, lineContains)` reads multiple fields from the same matching
line in a single pass. Two separate tail scans could return a mismatched
pair (primary from a newer record, secondary from an older one with only
the primary set); the new helper guarantees the pair is atomic. Validates
a proper closing quote on the primary value so a crash-truncated trailing
record can't win the latest-match race. `readLastJsonStringFieldsSync`
is its file-reading wrapper — same tail-window fast path and full-file
fallback as the single-field version, plus a `MAX_FULL_SCAN_BYTES = 64MB`
cap so a corrupt multi-GB session file can't freeze the picker. Session
reads now open with `O_NOFOLLOW` (falls back to plain RDONLY on Windows
where the constant isn't exposed) — defense in depth against a symlink
planted in `~/.qwen/projects/<proj>/chats/`.

Character handling: `flattenToTail` on the LLM prompt drops a dangling
low surrogate after `slice(-1000)` — otherwise a CJK supplementary char
or emoji cut mid-pair produces invalid UTF-16 that some providers 400.
`sanitizeTitle` applies the same surrogate scrub after max-length trim,
and strips paired CJK brackets (`「」 『』 【】 〈〉 《》`) as whole units so
a `【Draft】 Fix login` doesn't leave a dangling `】` after leading-char
strip. `lineContains` in the title reader is tightened from the loose
substring `'custom_title'` to `'"subtype":"custom_title"'` so user text
containing the literal `custom_title` can't shadow a real record.

Tests: 46 new unit tests across
- `sessionTitle.test.ts` (22): success/all-failure-reasons, tool-call
  filter, tail-slice, surrogate scrub, ANSI/OSC-8 strip, CJK brackets.
- `chatRecordingService.autoTitle.test.ts` (15): trigger/skip matrix,
  in-flight guard, abort propagation on finalize, manual/auto/legacy
  resume symmetry, cross-process race, env opt-out, retry-after-
  transient.
- `sessionStorageUtils.test.ts` (13): single-pass extractor, straddle
  boundary, truncated trailing record, lineContains, multi-field atom.
- `renameCommand.test.ts` (8): `--auto` success, all reasons, sentinel,
  unknown-flag hint, positional rejection, manual/SessionService
  fallbacks.

* docs(session): design doc for auto session titles

Matches the session-recap design doc shape (Overview / Triggers /
Architecture / Prompt Design / History Filtering / Persistence /
Concurrency / Configuration / Observability / Out of Scope) and adds a
Security Hardening section unique to the title path — titles render
directly in the picker and persist in user-readable JSONL, so
LLM-returned control sequences are an attack surface the recap path
doesn't have.

Captures decisions a code-only reader has to reverse-engineer:

- Why `maxAttempts: 1` (best-effort cosmetic metadata; no retry loop).
- Why `autoTitleAttempts` cap is 3 (first turn can be pure tool-call).
- Why the auto trigger does NOT fall back to the main model but
  session-recap does (auto-title fires on every turn; silently charging
  main-model tokens is a bill surprise).
- Why `titleSource: undefined` stays unwritten on legacy records (no
  rewrite risks silently reclassifying user intent).
- Why the cross-process re-read sits between the LLM await and the
  append (manual wins at both in-process and on-disk layers).
- Why `finalize()`'s abort tolerates a controller swap (in-flight
  identity check).
- Why JSON-schema function calling instead of tag extraction (avoid
  reasoning preamble bleed; cross-provider reliability).

Placed at docs/design/session-title/ alongside session-recap,
compact-mode, fork-subagent, and other per-feature design docs. No
sidebar index update required — the design folder is unindexed.

* test(rename): pin model choice in bare /rename kebab path

Addresses reviewer feedback: the bare `/rename` model selection
(`config.getFastModel() ?? config.getModel()`) had no test pinning
it either way. Previous tests mocked `getHistory: []`, which exits
the function before the model is ever chosen, so a silent regression
to either direction (always-main or always-fast) would pass CI.

Two explicit cases now:
- fastModel set → `generateContent` called with `model: 'qwen-turbo'`.
- fastModel unset → `generateContent` called with `model: 'main-model'`.

The tests intentionally mock a non-empty history so the kebab path
reaches the generateContent call site instead of bailing on empty input.

* fix(i18n): sync mismatched keys between en.js and zh.js (QwenLM#3503)

Add 4 keys missing from en.js that are actively used in source code,
add 5 missing Chinese translations to zh.js, integrate check-i18n
into CI to prevent future drift, and skip JSON file write in CI to
avoid dirtying the working tree.

---
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>

…M#3509)

* fix(cli): remove residual blank lines after MCP init completes (QwenLM#3095)

ConfigInitDisplay rendered <Box marginTop={1}> plus a content line, so
the live area grew by 2 rows during startup. When initialization
finished and the component unmounted, Ink shrank the live area but the
rows it had already committed to the terminal scrollback cannot be
reclaimed, leaving a visible gap above the input.

Move the MCP init status into the Footer's left-bottom status slot
(always mounted, fixed height) so the live area height stays constant
across the init → ready transition. The status participates in the
existing priority chain: ctrlC / ctrlD / escape / vim / shell /
autoAccept / configInit / hint.

* fix(cli): suppress MCP init message when custom status line is active

Audit follow-up. Previously the configInit branch preceded the
suppressHint branch in the footer's left-bottom priority chain. With
a custom status line configured, <Text>{null}</Text> collapses to
zero rows in Ink, so the footer's bottom row went from 1 row during
init to 0 rows after — a 1-row height oscillation that reintroduces
the same scrollback-residue symptom the original fix eliminated in
the default case.

Swap the order so suppressHint short-circuits to null first: the
init message now shares the hint's suppression rule, keeping the
footer's height constant in every configuration.

Also:
- Gate the hook's return on isConfigInitialized directly instead of
  letting the effect clear state, avoiding a one-frame flash where
  the stale "Initializing..." message leaks through on the first
  render after init completes.
- Cover the new behavior with three Footer tests, including a
  regression test for the custom-status-line case.

* fix(cli): show MCP init progress even under a custom status line

Reverting a UX trade-off introduced in the previous commit. That
change suppressed the init message whenever a custom status line was
active, arguing that <Text>{null}</Text> collapses to zero rows in
Ink and any non-zero init row would re-create a one-row shrink on
completion.

Zero shrink was the wrong goal. Hiding init progress from users who
have configured a status line is a real usability loss — the status
line does not surface MCP connection state, so those users now see
no feedback during startup. A one-time, one-line shrink on init
completion is a far smaller regression than the original two-row
scrollback residue this PR was created to fix, and strictly better
than the silent alternative.

Keep the init message in the left-bottom slot and let it sit above
suppressHint in the priority chain. Update the regression test so
that it pins the new behavior (init is visible with or without a
status line) and prevents the suppression from being reintroduced.

* fix(cli): keep MCP init progress visible in screen-reader mode

Footer is gated behind !isScreenReaderEnabled, so moving the init
message inside Footer silenced it for screen-reader users. Render the
same message as a plain Text node in Composer when the screen reader is
active — screen-reader users don't suffer from the live-area residual
row issue that motivated the original move, so an independent node is
safe for them.

* refactor(cli): drop duplicated screen-reader init path and show progress under YOLO

- ScreenReaderAppLayout already mounts <Footer /> directly, so the
  separate <Text> branch in Composer was producing a duplicated
  'Connecting to MCP servers...' line in screen-reader mode. Remove it.
- Move configInitMessage ahead of AutoAcceptIndicator in the footer's
  priority chain so users launched with YOLO / auto-accept-edits still
  see the ~1s startup progress; the approval-mode indicator takes over
  as soon as init finishes.
- Add unit tests for useConfigInitMessage covering the idle, progress,
  reset, and unsubscribe paths.

Co-authored-by: lawrence3699 <lawrence3699@users.noreply.github.com>

…ased approach (QwenLM#3502)

* feat(web-search): add GLM (ZhipuAI) web search provider

- Add GlmProvider class implementing BaseWebSearchProvider using the
  ZhipuAI Web Search API (https://open.bigmodel.cn/api/paas/v4/web_search)
- Support multiple search engines: search_std, search_pro, search_pro_sogou,
  search_pro_quark
- Support optional config: maxResults, searchIntent, searchRecencyFilter,
  contentSize, searchDomainFilter
- Truncate query to 70 characters per API limit
- Register 'glm' in the provider discriminated union (types.ts) and
  createProvider() switch (index.ts)
- Add GlmProviderConfig to settingsSchema, ConfigParams, and Config class
- Add --glm-api-key CLI flag and GLM_API_KEY env var support in webSearch.ts
- Forward GLM_API_KEY in sandbox environment
- Update provider priority list: Tavily > Google > GLM > DashScope
- Add 17 unit tests for GlmProvider and 4 integration tests in index.test.ts
- Update docs/developers/tools/web-search.md with GLM configuration,
  env vars, CLI args, pricing, and corrected DashScope billing info
- Fix stale OAuth/free-tier references in web-search.md

Closes QwenLM#3496

* docs(web-search): fix DashScope note and add GLM server-side limitations

* fix(web-search): make DashScope provider work with standard API key, remove qwen-oauth dependency

- DashScopeProvider.isAvailable() now checks config.apiKey instead of authType
- Remove OAuth credential file reading and resource_url requirement
- Use standard DashScope endpoint: dashscope.aliyuncs.com/api/v1/indices/plugin/web_search
- Read DASHSCOPE_API_KEY env var and --dashscope-api-key CLI flag
- Forward DASHSCOPE_API_KEY into sandbox environment
- Update integration test to detect DASHSCOPE_API_KEY
- Update docs to reflect new API key based configuration

* feat(web-search): remove built-in web search tool

The web_search tool and all related provider implementations are removed.
Web search functionality will be provided via MCP integrations instead,
which is the direction the broader agent ecosystem is moving.

Removed:
- packages/core/src/tools/web-search/ (entire directory)
- packages/cli/src/config/webSearch.ts
- integration-tests/cli/web_search.test.ts
- ToolNames.WEB_SEARCH, ToolErrorCode.WEB_SEARCH_FAILED
- webSearch config in ConfigParams, Config class, settingsSchema
- CLI options: --tavily-api-key, --google-api-key, --google-search-engine-id,
  --glm-api-key, --dashscope-api-key, --web-search-default
- Sandbox env forwarding for TAVILY/GLM/DASHSCOPE/GOOGLE search keys
- web_search from rule-parser, permission-manager, speculation gate,
  microcompact tool set, and builtin-agents tool list

* fix: remove websearch reference

* docs: remove websearch tool

* docs: add break change guide

* fix review

)

Selecting an older entry from input history via the arrow keys and pressing
Enter now moves that entry to the most recent position, so the next Up press
surfaces it first. Previously two bugs combined to keep stale copies in place:
the history-navigation index was not reset on submit, and deduplication only
collapsed consecutive repeats, leaving non-consecutive duplicates intact.

…3525) (QwenLM#3550)

* refactor(core): make OpenAI converter stateless to prevent shared-state races

Follow-up to QwenLM#3525. QwenLM#3516 showed that OpenAIContentConverter's long-lived
per-pipeline state raced between concurrent streams; QwenLM#3525 scoped the
streaming tool-call parser, this removes the remaining shared state.

- OpenAIContentConverter is now a module of stand-alone functions; the
  exported symbol is a namespace object preserved for call-site
  compatibility.
- New RequestContext (in types.ts, alongside PipelineConfig and
  ErrorHandler) carries model, modalities, startTime, and an optional
  per-stream toolCallParser. The pipeline builds one per request and
  threads it through every conversion call.
- errorHandler drops duration/isStreaming; duration is recomputed from
  startTime at error time and troubleshooting text is uniform.
- convertOpenAIChunkToGemini now throws if toolCallParser is missing so
  future misuse surfaces loudly instead of silently constructing a
  one-shot parser per chunk.

* test(core): align timeout expectations

…'error' event (QwenLM#3481)

* fix: strengthen error handling in launchBrowser to prevent unhandled events

* fix: strengthen error handling with ChildProcess type and debugLogger

* fix: use type-only import for ChildProcess

In ACP mode, the Mcp server list sent by the IDE client can include
SSE (type: "sse") and HTTP (type: "http") transports, but the previous
implementation only handled stdio servers via toStdioServer(). Non-stdio
servers were silently skipped (continue), so any SSE/HTTP-configured
MCP server would never be registered.

Changes:
- Add toSseServer() helper: detects type=="sse" servers and maps them
  to MCPServerConfig(url=..., headers=...)
- Add toHttpServer() helper: detects type=="http" servers and maps them
  to MCPServerConfig(httpUrl=..., headers=...)
- Refactor newSessionConfig() loop to handle all three transport types
- Declare mcpCapabilities: { sse: true, http: true } in agentCapabilities
  so IDE clients know this agent supports these transports without needing
  a transparent proxy
- Export the three helper functions for unit testing

Tests:
- Unit tests for toStdioServer / toSseServer / toHttpServer helpers
  (type discrimination, mutual exclusion)
- Integration-style tests for QwenAgent.initialize() mcpCapabilities
- Integration-style tests for newSession() with SSE/HTTP MCP servers,
  verifying MCPServerConfig is constructed with the correct arguments
  (url vs httpUrl, headers passthrough, empty-headers → undefined)

Fixes QwenLM#3472

…#3463)

* fix(cli): run ACP Agent tool calls concurrently (QwenLM#2516)

When the model returns multiple Agent tool calls in a single turn, the
ACP Session previously executed them sequentially in a plain for-loop,
multiplying latency by the number of sub-agents spawned.

Mirror the partition logic in coreToolScheduler.partitionToolCalls:
consecutive Agent calls form a parallel batch (safe because sub-agents
have no shared mutable state); any other tool forms its own sequential
batch so the model's implicit ordering is preserved. Response-part
ordering still matches the original functionCalls order.

Add a focused test that uses controllable deferred executes to prove
both Agent calls start before either resolves, and that the fed-back
functionResponse ordering is stable regardless of resolution order.

* Address PR QwenLM#3463 review: bound concurrency + robust test timing

Two issues raised by the /review bot:

1. The raw Promise.all fan-out bypassed the bounded-concurrency guard
   that coreToolScheduler applies via QWEN_CODE_MAX_TOOL_CONCURRENCY.
   Replaced with an inline runBounded helper that mirrors core's
   runConcurrently (Promise.race on a bounded executing set, default
   cap 10), keeping in-order result collection.

2. The concurrency test used a 10-iteration microtask yield loop before
   asserting both execute() spies had been invoked. That's fragile —
   runTool's pre-execute path (build → getDefaultPermission →
   evaluatePermissionRules → permission branch → PreToolUseHook) has
   more await boundaries than 10 ticks guarantees, and the CI run
   reported call-a still at 0 invocations at the assertion point.

   Reworked the test to wait on an explicit `called` deferred that
   resolves *inside* the execute() mock body. Under sequential
   behaviour only one `called` would ever fire → `Promise.all([called-a,
   called-b])` deadlocks → vitest's per-test timeout surfaces the
   regression. Under the fix both fire before either result resolves.

* fix(acp): degrade gracefully when AgentTool invocation has no eventEmitter

The concurrency test for QwenLM#2516 timed out on CI with "Test timed out in
5000ms" after the `await Promise.all([called-a, called-b])` rewrite in
the previous review-fix commit. The 5000ms wait was the symptom; the
root cause is that neither `execute()` was ever being called.

runTool's AgentTool branch was guarded with `'eventEmitter' in invocation`,
which is a *key-presence* check. The test mock provides
`{ eventEmitter: undefined, ... }` — the key exists (value undefined),
the branch is entered, and `SubAgentTracker.setup` immediately throws
inside `eventEmitter.on(...)`. The try/catch in runTool swallows the
throw and returns an error response, so `invocation.execute()` never
runs, `called[id].resolve()` never fires, and the test deadlocks.

The earlier review commit (4519c5f) interpreted the CI symptom as
"10 microtask yields aren't enough" and rewrote the assertion around a
deferred `Promise.all`. But the old test's `toHaveBeenCalledTimes(1)`
failure with 0 invocations was already the same bug — execute was never
called. The new formulation just converted the visible failure from an
assertion mismatch into a timeout.

Switch the guard to a truthy check against `invocation.eventEmitter`.
Semantics for real AgentTool are unchanged — `agent.ts:392` declares
`readonly eventEmitter: AgentEventEmitter = new AgentEventEmitter()`,
so production always enters the branch. The only new behavior is that
incomplete invocations (or test mocks) skip SubAgentTracker setup
cleanly instead of crashing. `subAgentCleanupFunctions` stays `[]`,
so the cleanup forEach at the success/error paths is a no-op.

…d 9;5u output (QwenLM#3544)

* fix(cli): disable Kitty keyboard protocol on SIGINT to prevent garbled 9;5u output

When a Kitty-capable terminal (iTerm2, Kitty, WezTerm) is used, the CLI
enables the Kitty keyboard protocol at startup via ESC[>1u. On exit, the
protocol must be disabled with ESC[<u to restore the terminal's default
key encoding. Failing to do so leaves the terminal in Kitty mode: any
subsequent Ctrl+C press is encoded as ESC[99;5u, and since the shell does
not understand this sequence, it echoes the trailing '9;5u' as garbled
text.

Root cause: kittyProtocolDetector registered cleanup handlers for 'exit'
and 'SIGTERM', but omitted SIGINT. A process terminated via SIGINT (e.g.
kill -INT <pid>, a parent process sending SIGINT, or certain process
managers) would exit without disabling the protocol.

Fix:
1. Add process.on('SIGINT', disableProtocol) alongside the existing
   'exit' and 'SIGTERM' handlers in kittyProtocolDetector.ts.
2. Export a new disableKittyProtocol() function for explicit call sites.
3. Call disableKittyProtocol() in the registerCleanup callback in
   gemini.tsx before instance.unmount(), so the disable sequence is
   written while stdout is fully operational regardless of exit path.

Fixes QwenLM#3528

* fix(test): add disableKittyProtocol to kittyProtocolDetector mock

…LM#3523)

* fix(cli): dispatch queued slash commands through the slash path

When the agent was responding and the user queued a message, the drain
path joined all queued messages with `\n\n` and submitted them as one
prompt. Any slash command in that blob (e.g. `/model`) no longer started
with `/`, so it was sent to the model as plain text instead of opening
the command's dialog.

The mid-turn tool-result drain had the same problem: it drained the
entire queue into the tool-result payload, so a slash command queued
during tool execution was injected as context for the model rather than
executed as a command.

Queue draining now splits into segments — consecutive plain-text
messages are still batched into one submission, while slash commands
are submitted alone so their `/` prefix survives. The mid-turn drain
only takes leading plain-text messages and leaves slash commands
queued for the normal idle drain. The idle drain is gated on open
dialogs so a queued `/model` does not cause the following queued
prompt to be sent to the model while the picker is still open, and a
re-entry lock plus a nonce close the race between state commits and
the async dialog-open.

* fix(cli): defer queued slash commands until idle

* fix(cli): drop queued messages on cancel instead of auto-submitting

Cancel's contract is now "abort and redirect" in both cancel paths:
restore the most recent queued segment into the buffer for editing and
drop the rest, so forgotten follow-ups cannot auto-submit once the turn
settles. Previously the non-tool path left queued plain-text segments
in place for the idle drain to fire, and the tool-executing path
cleared only the buffer — both surprised users with belated message
dispatches after they had already cancelled.

* refactor(cli): batch plain prompts in idle drain

Idle drain now runs in two phases: drain all plain-text prompts into one
turn (drainQueue), then pop slash commands one-by-one (popNextSegment).
Mirrors the mid-turn behavior so queue handling is consistent across
mid-turn and idle contexts.

popAllMessages now drains the entire queue joined with \n\n for Ctrl+C
cancel and ESC/Up edit-restore. Drop the unused options parameter from
useMessageQueue and the extractFirstSegment helper.

---------

Co-authored-by: 愚远 <zhenxing.tzx@alibaba-inc.com>

… sharing (QwenLM#3573)

QwenLM#3450 pinned every assistant/thinking segment in a streamed turn to the
same turn-start timestamp so a later user message could not be sorted
between two segments of the previous turn (QwenLM#3273). That fix turned out
to conflict with the tool-call timeline: tool calls carry their own
arrival timestamp, which is strictly greater than the turn-start
timestamp, so after QwenLM#3450 every tool call sorted AFTER both assistant
segments instead of between them — the exact 'tool call jumped to the
end' ordering bug users are now reporting.

The two bugs pull the sort key in opposite directions and cannot both
be satisfied by a single timestamp strategy. Roll QwenLM#3450 back byte-for-
byte on useMessageHandling.ts so the tool-call ordering regression is
fixed immediately; replace the test file with two focused cases that
pin the conflicting invariants so the next fix (likely a monotonic
sequence key shared across messages and tool calls) has a clear
target:

  - tool-call interleave test (passes today): a tool call that arrives
    between two assistant segments must sort strictly between them.
  - QwenLM#3273 regression test (it.fails today): all assistant segments of
    one turn must sort before a user message sent during the turn.
    Flipped to a normal it() once the proper fix lands.

Refs: QwenLM#3273, QwenLM#3450

Co-authored-by: Qwen-Coder <noreply@qwenlm.ai>

…LM#3575)

- Add new skills: bugfix, feat-dev with structured workflows
- Update existing skills: docs-audit-and-refresh, docs-update-from-diff,
  e2e-testing, qwen-code-claw, structured-debugging, terminal-capture
- Update test-engineer agent with clearer constraints and formatting
- Update qc commands: bugfix, code-review, commit, create-issue, create-pr
- Reorganize .gitignore to keep qwen configs near top
- Expand AGENTS.md with development commands, feature/bugfix workflows,
  project directories table, and code review guidelines

Co-authored-by: 愚远 <zhenxing.tzx@alibaba-inc.com>
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>

…e sessions (GH#3579) (QwenLM#3590)

* fix(core): preserve reasoning_content during session resume and active sessions (GH#3579)

* chore(core): remove dead thinkingThresholdMinutes config after latch removal (GH#3579)

…nLM#3613) (QwenLM#3620)

Some OpenAI-compatible servers (notably sglang's deepseek-v4 jinja
template) crash on the array form of message content even when it
carries a single text block, with `TypeError: sequence item 0:
expected str instance, list found` at `encoding_dsv4.py:336`.

The DeepSeekOpenAICompatibleProvider already flattens content arrays
into joined strings in buildRequest, but isDeepSeekProvider only
matched on the official api.deepseek.com baseUrl. DeepSeek models
served behind sglang / vllm / ollama / etc. bypass the workaround
and hit the bug.

Extend the matcher to also detect by model name (case-insensitive
substring 'deepseek'), so any OpenAI-compatible endpoint serving a
DeepSeek model picks up the same content-format flattening.

Fixes QwenLM#3613

Co-authored-by: wenshao <wenshao@U-K7F6PQY3-2157.local>

…tion (QwenLM#3567)" (QwenLM#3633)

This reverts commit 007a109.

The change made `OPENAI_MODEL` outrank `settings.model.name` when looking
up the active entry in `settings.modelProviders`. Combined with the core
resolver's `modelProvider > cli > env > settings` priority, this caused
a regression: a `/model` selection (which writes `settings.model.name`)
was silently overridden whenever `OPENAI_MODEL` was set in the user's
shell, with no warning surfaced.

Restoring the previous behavior — looking up the provider entry by
`argv.model || settings.model?.name` — preserves the implicit contract
that an explicit `modelProviders` config takes precedence over stale
shell defaults. Users without a `modelProviders` config are unaffected:
env vars still drive model selection through the core resolver.

See discussion on QwenLM#3567.

* Initial version

* Some fixes

* Fix sentences

* More fixes

* Fix

* Latest fixes

…message submit (QwenLM#3609)

* fix(vscode-companion): slash command completion not triggering after message submit

After submitting a message, the input field is cleared with a zero-width
space (\u200B) to maintain contentEditable height. When the user then
types "/", the DOM content becomes "\u200B/" and the trigger character
lands at position 1 instead of 0. The word boundary check only recognized
regular space and newline, so the zero-width space was rejected as an
invalid boundary — preventing the completion popup from appearing.

Add \u200B to the valid word boundary characters so "/" and "@" triggers
work correctly after message submission without requiring an extra
backspace.

Closes QwenLM#3592

* refactor(webui): extract zero-width space placeholder into shared constant

Replace scattered `\u200B` magic strings with a shared `ZERO_WIDTH_SPACE`
constant and `stripZeroWidthSpaces()` helper exported from @qwen-code/webui.

This also improves the slash command completion fix: instead of adding
\u200B to the word boundary check, strip it at the source in handleInput
(consistent with InputForm's onInput handler) and clamp the cursor
position to the stripped text length.

Closes QwenLM#3592

* test: add tests for zero-width space handling and shouldSendMessage

- Add unit tests for ZERO_WIDTH_SPACE constant and stripZeroWidthSpaces
  helper (via @qwen-code/webui import)
- Add shouldSendMessage tests covering empty, whitespace, zero-width
  space, and attachment scenarios
- Add parseExportSlashCommand tests for zero-width space input

* fix(test): use correct ImageAttachment type in shouldSendMessage tests

Fix CI lint failure by providing all required ImageAttachment fields
(id, name, type, size, data, timestamp) instead of non-existent
mediaType property.

…uth paths (QwenLM#3629)

* feat(config): support API timeout env override

Adds support for QWEN_CODE_API_TIMEOUT_MS as an environment override
for model generation timeout.

Qwen Code already supports timeout configuration via:
  settings.model.generationConfig.timeout

This change introduces an env-based override for users running slow
local/OpenAI-compatible backends where editing config is less convenient.

Precedence: modelProvider > env var > settings > default (120000ms)

Behavior:
- Valid positive env values override configured timeout
- Invalid values are ignored
- Default behavior remains unchanged (applied in buildClient())

Note: The 5-minute timeout reported in QwenLM#1045 originally came from
undici's default bodyTimeout, which is now disabled (bodyTimeout:0).
The modelConfigResolver default is 120000ms (2 minutes).

Includes unit tests covering precedence and validation.

Closes QwenLM#1045

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* test(core): add edge-case tests for QWEN_CODE_API_TIMEOUT_MS

Covers: large timeout values, whitespace-padded env values,
negative env values, and reinforces provider > env > settings precedence.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* feat(config): support QWEN_CODE_API_TIMEOUT_MS override

Adds support for QWEN_CODE_API_TIMEOUT_MS as an environment
override for model generation timeout.

Closes #13

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Fire a fire-and-forget HEAD request early in startup to warm the TCP+TLS connection. Subsequent SDK calls share an undici dispatcher with preconnect, reusing the warmed connection to save 100-200ms on the first request.

Skip conditions:
- NODE_EXTRA_CA_CERTS set (enterprise TLS inspection)
- Sandbox mode (process-restart context)
- Non-default baseUrl (mTLS / private deployment)
- Non-Node runtimes (Bun)

Disable via QWEN_CODE_DISABLE_PRECONNECT=1.

Closes QwenLM#3223

Adds argument-hint support across the slash command pipeline. Skill and command authors specify an argument-hint field in markdown frontmatter, which renders as inline ghost text when the user has typed the command name but not yet provided arguments.

Pipeline:
- Skill parsing: SkillConfig.argumentHint parsed from SKILL.md frontmatter
- Command loaders: propagated through SkillCommandLoader, BundledSkillLoader, FileCommandLoader, command-factory
- UI: useCommandCompletion shows hint as ghost text with showCursorBeforeText layout; InputPrompt separates display text from Tab-accept text
- ACP: passed as input.hint per spec
- Bundled skills (batch, loop, qc-helper, review) get hints

Hint is excluded from completion menu labels to keep the dropdown clean and disappears as soon as the user starts typing arguments.

…wenLM#3653)

Extract duplicated timeout env override block into a shared helper
applyTimeoutEnvOverride(), used by both resolveModelConfig() and
resolveQwenOAuthConfig(). Preserves precedence:
modelProvider > env > settings > default.

Adds [Regression] and [Additional] tests guarding against the
original OAuth-path bug and covering edge cases.

# Conflicts:
#	docs/users/configuration/settings.md
#	integration-tests/globalSetup.ts
#	packages/cli/src/ui/commands/memoryCommand.test.ts
#	packages/cli/src/ui/commands/memoryCommand.ts
#	packages/cli/src/ui/components/InputPrompt.test.tsx
#	packages/cli/src/ui/components/SettingsDialog.test.tsx
#	packages/core/src/core/prompts.test.ts
#	packages/core/src/core/prompts.ts
#	packages/core/src/extension/extensionManager.ts
#	packages/core/src/qwen/qwenOAuth2.ts
#	packages/core/src/skills/skill-manager.ts
#	packages/core/src/tools/memoryTool.ts
#	packages/core/src/tools/web-search/providers/dashscope-provider.ts
#	packages/vscode-ide-companion/src/services/qwenSessionReader.ts

Removes 'does not accept the prompt suggestion on shift+tab' from
InputPrompt.test.tsx and 'should keep restart prompt when switching
scopes' from SettingsDialog.test.tsx. Both have been observed to fail
intermittently on the Windows CI workers; the underlying behaviors are
covered by adjacent assertions and end-to-end tests.

The QWEN_HOME refactor incorrectly routed the QWEN_SYSTEM_MD default path
through Storage.getGlobalQwenDir() (i.e. ~/.qwen/system.md or
$QWEN_HOME/system.md). The original semantics — inherited from the
upstream Gemini-CLI sync — are project-local: <cwd>/.qwen/system.md.

System-prompt customization is intentionally per-project so that each
repository can ship its own override without global side effects. Users
who want a global override can still set QWEN_SYSTEM_MD to an absolute
path. This revert keeps that behavior intact while leaving the rest of
the QWEN_HOME plumbing (settings, credentials, extensions, skills, memory)
unchanged.

Three definitions of the literal '.qwen' string existed across the
codebase:

- QWEN_DIR in config/storage.ts (canonical, used by the Storage class)
- QWEN_CONFIG_DIR in memory/const.ts
- QWEN_CONFIG_DIR in tools/memory-config.ts (a near-clone of the above)

The QWEN_CONFIG_DIR name also collided with a former env-var name (now
renamed to QWEN_HOME on this branch), making it ambiguous whether call
sites referred to a configurable env var or a hardcoded directory name.

Drop the duplicates and route the only call sites (prompts.ts and its
test) through QWEN_DIR from config/storage.ts. The mock factory in
config.test.ts is updated to no longer expose the removed export.

…ration

Tests 2b and 3a in cli/qwen-config-dir.test.ts relied on running
\`qwen --help\` to invoke loadSettings() (and thus the V1→V3 settings
migration). That worked when loadSettings() ran before parseArguments()
in the CLI startup sequence. Main has since flipped the order:
parseArguments() runs first, and yargs intercepts --help and exits the
process before loadSettings() is reached, so migration never runs and
the tests' migration probe always reads back V1.

Switch to \`qwen extensions list\` instead. It is a yargs subcommand that
runs through main() to loadSettings() without requiring an API key, so
migration runs as expected. Update the inline comments to document why
--help cannot be used and why this command works.

…Dir()

The auto-memory subsystem (introduced on main in QwenLM#3087) computed its base
directory by hardcoding path.join(os.homedir(), QWEN_DIR). That bypassed
QWEN_HOME entirely, so global auto-memory artifacts always landed in
~/.qwen/projects/... regardless of the user's configured QWEN_HOME path.

Route the default through Storage.getGlobalQwenDir() so QWEN_HOME is
honored. The QWEN_CODE_MEMORY_BASE_DIR test override stays as the
highest-priority short-circuit.

Discovered while running the QWEN_HOME e2e test plan against the merged
branch — Group B test B3 (memory tool writes to QWEN_HOME) was the only
failing scenario across A/B/C/D groups.

When QWEN_HOME points to a directory whose path does not contain
`.qwen` (e.g., `/tmp/qwen-home`), the global `.env` was misclassified
as a project-level env file. As a result, default-excluded variables
such as `DEBUG` and `DEBUG_MODE` were silently dropped even though
they came from the user-level config directory.

The classification now reuses the same user-level path set computed
by `findEnvFile`, so any `.env` inside the resolved global Qwen
directory (or directly under `~/`) is recognized as user-level.

Also drop the misleading "does not expand `~`" note from the
QWEN_HOME documentation — `Storage.getGlobalQwenDir` does expand
leading tildes via `Storage.resolvePath`.