Thanks for the thorough review — all addressed in fa384c78d:

1. [Critical] Skill tool clobbers inline override — Fixed. A turn whose model override came from an explicit /model <id> <prompt> now sets an inlineModelOverrideActiveRef that takes precedence for the whole turn; the skill-tool override loop (including the undefined-clears case) is skipped while it's active, and the flag resets on the next user turn alongside modelOverrideRef.
2. [Critical] Non-interactive/ACP drops modelOverride — Non-interactive was wired in an earlier commit (the result type now carries modelOverride and the run loop seeds its per-turn override from it; verified via OpenAI request logging). For ACP, the send pipeline doesn't thread a per-turn override, so rather than silently run on the session model the inline form is now rejected in ACP mode with a hint to use the two-step /model <id> flow.
3. [Critical] Stale description assertion — Fixed; the test now asserts the updated description (this was the CI failure).
4. [Suggestion] @file expansion bypass — Documented in the command description for now (the inline prompt is sent verbatim without @file expansion); this is shared by all submit_prompt commands, so routing inline prompts through the full preprocessing pipeline is noted as a follow-up.
5. [Suggestion] Misleading argumentHint — Updated to [--fast|--voice|--vision] [<model-id>] | <model-id> <prompt>.

@qwen-code /review

@qwen-code /triage

Thanks for the PR!

Template looks good ✓

On direction: this is a solid quality-of-life improvement — collapsing the switch→prompt→switch-back dance into a single /model <id> <prompt> line is exactly the kind of CLI shortcut users expect. Closes #5967 cleanly. No direct Claude Code equivalent found in their CHANGELOG, but the model-management area is clearly in scope. The scope decision to reject cross-provider inline overrides (pointing users to the two-step /model <id> flow) is pragmatic for v1.

On approach: the design is well-thought-out. The producer/consumer split — modelCommand produces the modelOverride, the consumer (useGeminiStream / nonInteractiveCli) validates provider identity before applying — is good defensive engineering. The ACP rejection is the right call since ACP's send pipeline doesn't thread per-turn overrides. The coupled-refs pattern (modelOverrideRef + inlineModelOverrideActiveRef) with applyModelOverride/clearModelOverride helpers adds some ceremony but correctly guards the tricky skill-tool precedence case. The diff is ~870 lines but the bulk is test coverage (~550 lines across 5 test files), which is proportional. The implementation itself is focused — every change serves the stated goal, no drive-by refactors or scope creep.

Moving on to code review. 🔍

— Qwen Code · qwen3.7-max

Code Review

Read through the full diff and the key changed files (modelCommand.ts, useGeminiStream.ts, acpModelUtils.ts, nonInteractiveCli.ts). The implementation is clean — no critical blockers found.

The producer/consumer validation split is well-executed: modelCommand validates the model exists on the target auth type, then the consumers (useGeminiStream for interactive, nonInteractiveCli for headless) independently re-validate provider identity via isInlineModelOverrideAllowed before applying the override. This defense-in-depth means a buggy or malicious slash command can't silently redirect API calls to a different provider.

The coupled-refs pattern (modelOverrideRef + inlineModelOverrideActiveRef) with applyModelOverride/clearModelOverride helpers is the right level of ceremony for the skill-tool precedence problem. The retry-clearing logic is also correct: inline overrides drop on retry (one-shot is done), skill-tool overrides survive (continuation semantics). The info message on retry-clear is a nice touch — makes the silent model switch visible.

The ACP rejection is properly scoped — ACP's send pipeline doesn't thread per-turn overrides, so rejecting the inline form prevents silent misrouting.

One small note: the isInlineModelOverrideAllowed function duplicates some of the provider-identity logic that conceptually lives in modelCommand's existing availableModels check. Not a blocker — the consumer-side re-validation is a deliberate design choice and the function is well-named and tested.

Build & Tests

• npm run build — ✅ clean (only pre-existing warnings)
• npm run typecheck — ✅ clean
• modelCommand.test.ts — 53/53 ✅
• acpModelUtils.test.ts — 27/27 ✅
• nonInteractiveCliCommands.test.ts — 37/37 ✅
• loggers.test.ts — 57/57 ✅
• useGeminiStream.test.tsx (inline model override) — 2/2 ✅

Real-Scenario Testing (tmux)

Tested non-interactive mode with the PR code. Without API credentials on this runner, the tests exercise the command-parsing and error paths.

Test 1: /model nonexistent-model say hello — invalid model with trailing prompt

github-runner@iZt4neqpisqczs6hsm7xn2Z:~$ npm run dev -- -p '/model nonexistent-model say hello' 2>&1

> @qwen-code/[email protected] dev
> node scripts/dev.js -p /model nonexistent-model say hello

Model 'nonexistent-model' is not available for auth type 'openai'.
No models are configured for auth type 'openai'.
Configure models in settings.modelProviders and ensure the required environment variables are set. In interactive mode, run /auth to configure or switch providers, or run /model without arguments to choose from configured models.

✅ Model name correctly parsed from nonexistent-model say hello (first word = model id, rest = prompt). Error path fires before any API call. Error message includes the configuration hint.

Test 2: /model (no args) — unchanged baseline

github-runner@iZt4neqpisqczs6hsm7xn2Z:~$ npm run dev -- -p '/model' 2>&1

> @qwen-code/[email protected] dev
> node scripts/dev.js -p /model

Current model: qwen3.7-max
Use "/model <model-id>" to switch models or "/model --fast <model-id>" to set the fast model.

✅ No-args path is unchanged — still shows current model and usage hint. The inline prompt feature doesn't affect existing behavior.

Note: The actual override behavior (running a prompt on a different model) requires live API credentials which aren't available in this CI environment. The unit tests thoroughly cover the override application, skill-tool precedence, retry clearing, and cross-provider rejection paths.

— Qwen Code · qwen3.7-max

Reflection

Stepping back: this PR does exactly what it says on the tin. The motivation is clear (3 steps → 1 step for one-shot model use), the implementation is focused, and the tests are thorough. The code reads like someone who has thought carefully about the failure modes — the coupled-refs pattern exists because a naive revert-based approach would leave the session stuck on the wrong model after Ctrl+C or an API error, and the skill-tool precedence guard exists because skill tools can legitimately set their own modelOverride mid-turn.

My independent proposal would have been simpler (single ref, no skill-tool guard), which means it would have been wrong in edge cases. The PR's approach is better.

The isInlineModelOverrideAllowed function is a small, well-named, well-tested piece of provider-identity validation that gets reused in all three consumers (modelCommand, useGeminiStream, nonInteractiveCli). No unnecessary abstractions, no speculative features.

Build is clean, typecheck is clean, all 176 tests pass, tmux testing confirms the command-parsing and error paths work in real usage. The prior review's critical issues (skill-tool clobbering, ACP dropping the override, stale test assertion) have all been addressed.

This is ready to ship. ✅

— Qwen Code · qwen3.7-max

✅ Maintainer local verification — real binary E2E + unit suites

I built the real bundled binary at this PR's head (3ec156f3f) and verified the inline one-shot /model <id> <prompt> override end-to-end against a fake OpenAI endpoint that records the model field actually sent on the wire (client.ts → options?.modelOverride ?? config.getModel()). Every headline claim in the PR description reproduces. No behavioral discrepancies found.

Proof the binary ran this PR's code (not main): the runtime debug log emitted model override set to override-model (inline=true) — the (inline=${isInline}) template exists only in this PR's applyModelOverride and is absent on origin/main.

Environment

• Worktree at PR head 3ec156f3f (merge of origin/main into feat/inline-model-override), Node v22.22.2, macOS.
• npm ci + npm run bundle → real dist/cli.js (v0.19.3). npm run typecheck ✅ (all workspaces).
• Isolated HOME with a modelProviders.openai catalog; two models (session-model default + override-model) share one baseUrl+envKey (same provider identity), plus decoys for the rejection cases.

1. Unit / component suites (vitest at head) — 176 passed

2. Non-interactive E2E (real binary → fake endpoint)

Each row is the model observed on the wire:

3. Interactive TUI E2E (tmux, one live session) — the auto-revert

Runtime debug log corroborates the lifecycle exactly:

model override set to override-model (inline=true)   ← turn 1 (inline command)
model override cleared (inline=false)                ← turn 2 (next user turn → auto-revert)

Turn 1 = one-shot (no session switch, indicator unchanged); Turn 3 = bare /model <id> still switches & persists ⇒ the if (inlinePrompt) guard preserves existing behavior.

4. Tool-loop continuation E2E (the design rationale)

Forced a list_directory tool call on the override turn, then text on the continuation:

#0 stage=initial       model=override-model   (returns tool_call)
#1 stage=continuation   model=override-model   (after tool result fed back)  ✅
final: DONE_AFTER_TOOL[override-model]

The override persists across the entire tool-call loop and does not revert mid-turn — confirming the per-turn modelOverride design (vs switchModel()+revert) behaves as claimed.

Verdict

The implementation does exactly what the description says: inline form runs one turn (incl. tool-call continuations) on the target model, auto-reverts on the next user turn, never switches/persists the session model, never leaks into background subagents, and rejects invalid ids / cross-provider / same-id-different-endpoint targets with clear messages. Build, typecheck, and all touched unit suites pass. LGTM from a behavioral-verification standpoint.

model override set to override-model (inline=true)   ← 第 1 轮（内联命令）
model override cleared (inline=false)                ← 第 2 轮（下一个用户轮 → 自动回退）

#0 stage=initial       model=override-model   （返回 tool_call）
#1 stage=continuation   model=override-model   （工具结果回灌之后）  ✅
最终：DONE_AFTER_TOOL[override-model]

_{Verification harness: real bundled binary + fake OpenAI endpoint recording the wire model + tmux-driven TUI; not affiliated with any model/vendor. Build & tooling run locally by the maintainer.}

✅ Maintainer local verification — real-binary E2E (interactive TUI + non-interactive)

I built the actual PR head (3ec156f3f) into a real qwen bundle (npm ci → build core → npm run bundle, v0.19.3) and exercised it against a fake OpenAI endpoint that records the model field of every outgoing request, in both qwen -p (non-interactive) and a live interactive TUI driven through tmux. This closes the two gaps the PR flagged as “not validated”: the interactive TUI before/after capture, and the tool-call-continuation claim.

Setup — a same-provider modelProviders.openai registry with three models, all envKey: OPENAI_API_KEY:

• model-alpha → fake server (session default)
• model-beta → fake server (valid inline-override target)
• model-gamma → different baseUrl (same auth type, different provider identity → must be rejected)

The fake server echoes the received model back as the reply (REPLY_FROM_MODEL[<model>]) and independently logs each request's model server-side; both agree on every turn, so the request model is authoritative ground truth.

Results

Key evidence

Inline override + auto-revert (interactive TUI):

> /model model-beta reply with exactly: OVERRIDE_TURN_AAA
✦ REPLY_FROM_MODEL[model-beta]          # request #0 model=model-beta
> reply with exactly: REVERT_TURN_BBB
✦ REPLY_FROM_MODEL[model-alpha]         # request #3 model=model-alpha (reverted)
# background subagents in between: model=model-alpha (no leak)

Revert targets the session model, not a constant — with the session switched to Beta, a one-shot /model model-alpha … ran exactly one turn on alpha, background subagents stayed on Beta, and the next plain turn reverted to Beta (request #3 model=model-beta); header remained Beta throughout.

Override survives the tool loop (the central design claim):

#0 model=model-alpha kind=tool-initial        # emitted list_directory
#1 model=model-alpha kind=tool-continuation    # tool result fed back, still alpha
#2 model=model-beta  (background suggestion)   # session model

Cross-provider rejection is by provider identity, not just auth type: model-gamma is registered under the same openai auth type but a different baseUrl; the inline form is correctly rejected (the per-turn override reuses the active endpoint/credentials and can't rebuild them), while the two-step /model <id> is still offered.

Tests / static checks (on the worktree at PR head)

• 326 unit tests pass across the changed files: modelCommand 53, acpModelUtils 27, nonInteractiveCliCommands 37, useGeminiStream 152, loggers 57. The hardest edges are covered there: “clears the inline override on retry and reverts to the session model” and “a skill tool with modelOverride: undefined does not clobber an active inline override”.
• tsc --noEmit clean for core and cli; eslint clean on all 11 changed source files; check-i18n passes (en.js base, zh/zh-TW in sync).
• CI Test (ubuntu-latest) leg is green.

Conclusion

Every documented behavior reproduces on the real binary, including the two items the description marked not validated (interactive TUI A/B and tool-call continuation). The override applies to the turn and all its tool-call continuations, never leaks into background subagents, reverts to the current session model, and never mutates or persists session state; invalid / cross-provider inputs are rejected with no outgoing call. No regressions or defects found. LGTM for merge (v1 same-provider scope).

> /model model-beta reply with exactly: OVERRIDE_TURN_AAA
✦ REPLY_FROM_MODEL[model-beta]          # 请求 #0 model=model-beta
> reply with exactly: REVERT_TURN_BBB
✦ REPLY_FROM_MODEL[model-alpha]         # 请求 #3 model=model-alpha（已回退）
# 中间的后台子代理：model=model-alpha（无泄漏）

#0 model=model-alpha kind=tool-initial        # 发出 list_directory
#1 model=model-alpha kind=tool-continuation    # 工具结果回灌后仍是 alpha
#2 model=model-beta  （后台输入建议）           # 会话模型

_{Verified at head 3ec156f3f. Methodology: real bundled qwen + a fake OpenAI server logging each request's model, driven via qwen -p and a tmux-driven interactive TUI.}