openyida 2026.10.26-beta.1 → 2026.10.26-beta.2

package/README.md

@@ -143,6 +143,8 @@ openyida login --check-only --json
 openyida auth status
 ```
 
+In QwenWork web, `openyida login --qwenwork --json` (or ordinary `login`) exchanges the cloud runtime credential for a verified YiDA session on the selected YiDA endpoint. Login preparation stays silent; failures stop without browser OAuth. Desktop and other hosts retain their existing authentication paths.
+
 For QwenWork cloud identity diagnostics, run inside the actual cloud execution environment:
 
 ```bash

package/bin/yida.js

@@ -601,9 +601,11 @@ async function main() {
       return;
   }
   applyGlobalEnvironmentFlags();
-  // 桌面准备完成后继续执行公开命令，由真实登录态决定结果。
-  if (command === 'login' && args.includes('--qwenwork')) {
-    const loginArgs = applyLoginEnvironmentFlags(args, { inferTargetUrl: true });
+  // 网页态由 CLI 消费宿主凭据；桌面态继续消费宿主准备的登录态。
+  const webLogin = (command === 'login' || (command === 'auth' && args[0] === 'login')) &&
+    require('../lib/core/qwenwork-login-guidance').isQwenWorkWebRuntime(require('../lib/core/utils').detectRuntimeCapabilities());
+  if ((command === 'login' && args.includes('--qwenwork')) || webLogin) {
+    const loginArgs = applyLoginEnvironmentFlags(command === 'auth' ? args.slice(1) : args, { inferTargetUrl: true });
     if (hasHelpFlag(loginArgs)) { printLoginHelp(); return; }
     assertNoUnsupportedLegacyLoginFlags(rawArgs, loginArgs);
     await require('../lib/auth/qwenwork-login').run(loginArgs, buildTokenLoginOptions(loginArgs));

package/lib/auth/qwenwork-cloud.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const { CliError } = require('../core/cli-error');
+const { t } = require('../core/i18n');
+const { DINGTALK_OAUTH_CLIENT_ID } = require('../core/env-manager');
+const { resolveTokenBaseUrl } = require('./token-auth');
+const { exchangeQwenWorkAgentToken, getQwenWorkUserInfo } = require('./qwenwork-client');
+
+function failure(code, details = {}) {
+  return new CliError(t('qwenwork.login_check_failed'), { code: `QWENWORK_CLOUD_${code}`, details });
+}
+
+function origin(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== 'https:' || url.username || url.password || url.pathname !== '/' || url.search || url.hash) { throw new Error(); }
+    return url.origin;
+  } catch { throw failure('ENDPOINT_INVALID'); }
+}
+
+async function exchangeSession(credential, baseUrl, options) {
+  const controller = new AbortController();
+  const timeoutMs = options.timeoutMs === undefined ? 15000 : options.timeoutMs;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) { throw failure('INVALID_TIMEOUT'); }
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await (options.fetch || globalThis.fetch)(`${baseUrl}/openapi/cli/v1/auth/qwenwork/token`, {
+      method: 'POST', redirect: 'error', signal: controller.signal,
+      headers: { authorization: `Bearer ${credential.access_token}`, accept: 'application/json', 'content-type': 'application/json' },
+      body: JSON.stringify(options.corpId ? { corp_id: options.corpId } : {}),
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw failure('HTTP_ERROR', { stage: 'yida_exchange', status_code: response.status });
+    }
+    const reader = response.body?.getReader();
+    if (!reader) { throw failure('RESPONSE_INVALID'); }
+    const chunks = []; let bytes = 0;
+    try {
+      for (let part = await reader.read(); !part.done; part = await reader.read()) {
+        bytes += part.value.byteLength;
+        if (bytes > 65536) { await reader.cancel(); throw failure('RESPONSE_INVALID'); }
+        chunks.push(part.value);
+      }
+    } finally { reader.releaseLock(); }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+  } catch (error) {
+    // 上游正文和异常可能回显凭据，仅保留本模块生成的固定错误码。
+    if (error instanceof CliError && /^QWENWORK_CLOUD_/.test(error.code)) { throw error; }
+    throw failure(controller.signal.aborted ? 'REQUEST_TIMED_OUT' : 'REQUEST_FAILED');
+  } finally { clearTimeout(timer); }
+}
+
+/** 仅在内存中兑换千问凭据；返回宜搭会话供调用方校验后保存。 */
+async function exchangeQwenWorkCloudSession(options = {}) {
+  const baseUrl = origin(options.endpoint || (options.env || process.env).OPENYIDA_ENDPOINT || resolveTokenBaseUrl(options));
+  const credential = await exchangeQwenWorkAgentToken(options);
+  try {
+    const profile = await getQwenWorkUserInfo(credential, options);
+    if (profile.is_biz !== true || !profile.biz?.org_id) { throw failure('ENTERPRISE_REQUIRED'); }
+    const startedAt = Date.now();
+    const value = await exchangeSession(credential, baseUrl, options);
+    if (!value || value.status !== 'ok' || value.auth_mode !== 'token' || value.can_auto_use !== true ||
+      value.token_type !== 'Bearer' || value.credential_source !== 'qwenwork_cloud' ||
+      typeof value.access_token !== 'string' || !value.access_token || /\s/.test(value.access_token) || value.access_token.length > 32768 ||
+      value.access_token === credential.access_token ||
+      ['QWENWORK_AGENT_TOKEN', 'MULE_AGENT_TOKEN', 'AGENT_TOKEN'].some(name => value.access_token === (options.env || process.env)[name]) ||
+      !Number.isInteger(value.expires_in) || value.expires_in <= 0 || value.expires_in > 1800 ||
+      typeof value.corp_id !== 'string' || !/^ding[0-9a-f]{32}$/.test(value.corp_id) ||
+      typeof value.user_id !== 'string' || !value.user_id || value.user_id.trim() !== value.user_id || value.user_id.length > 256 ||
+      (options.corpId && value.corp_id !== options.corpId) ||
+      (options.userId && value.user_id !== options.userId) ||
+      (value.base_url !== undefined && origin(value.base_url) !== baseUrl) ||
+      'refresh_token' in value || 'refreshToken' in value || 'exchange_ticket' in value) { throw failure('RESPONSE_INVALID'); }
+    return {
+      auth_mode: 'token', credential_source: 'qwenwork_cloud', token_type: 'Bearer',
+      access_token: value.access_token, base_url: baseUrl,
+      client_id: options.clientId || DINGTALK_OAUTH_CLIENT_ID,
+      corp_id: value.corp_id, user_id: value.user_id,
+      expires_at: startedAt + value.expires_in * 1000,
+    };
+  } finally { credential.access_token = undefined; }
+}
+
+module.exports = { exchangeQwenWorkCloudSession };

package/lib/auth/qwenwork-login.js

@@ -1,7 +1,10 @@
 'use strict';
 const { t } = require('../core/i18n');
 const { CliError } = require('../core/cli-error');
-const { loadTokenSession, resolveTokenSession, isEnvTokenAuthMode } = require('./token-store');
+const { loadTokenSession, resolveTokenSession, isEnvTokenAuthMode, hasEnvTokenCredential, saveTokenSession } = require('./token-store');
+const { detectRuntimeCapabilities } = require('../core/utils');
+const { isQwenWorkWebRuntime } = require('../core/qwenwork-login-guidance');
+const { exchangeQwenWorkCloudSession } = require('./qwenwork-cloud');
 const { tokenLogin, tokenRefresh, isRefreshAuthRequired } = require('./token-auth');
 
 function failure(code) {
@@ -45,8 +48,26 @@ async function verify(session, options = {}) {
   } finally { clearTimeout(timer); }
 }
 
-/** 公开入口复用、刷新登录态；确需授权时复用普通 login 的前台 OAuth 流程。 */
+/** 网页态消费宿主凭据；其他宿主保留已有登录态与前台 OAuth 流程。 */
 async function ensureQwenWorkLogin(options = {}, dependencies = {}) {
+  const env = options.env || process.env;
+  const runtime = options.runtime || detectRuntimeCapabilities({ env });
+  if (isQwenWorkWebRuntime(runtime) && !isEnvTokenAuthMode(env) && !hasEnvTokenCredential(env)) {
+    if (options.checkOnly) { return summary(await verify(loadTokenSession(options), options)); }
+    const selectedProfile = options.authProfile || options.profile || env.OPENYIDA_AUTH_PROFILE;
+    const selectedSession = selectedProfile ? loadTokenSession(options) : null;
+    if (selectedProfile && !selectedSession) { throw failure('AUTH_PROFILE_REQUIRED'); }
+    const cloudOptions = {
+      ...options,
+      endpoint: options.endpoint || env.OPENYIDA_ENDPOINT || selectedSession?.base_url,
+      corpId: options.corpId || env.OPENYIDA_AUTH_CORP_ID || selectedSession?.corp_id,
+      userId: options.userId || env.OPENYIDA_AUTH_USER_ID || selectedSession?.user_id,
+    };
+    const session = await exchangeQwenWorkCloudSession(cloudOptions);
+    if (!await verify(session, options)) { throw failure('QWENWORK_LOGIN_CHECK_FAILED'); }
+    saveTokenSession(session, options);
+    return summary(true);
+  }
   const resolution = resolveTokenSession(options);
   if (resolution.status === 'profile_required') { throw failure('AUTH_PROFILE_REQUIRED'); }
   let session = loadTokenSession(options);
@@ -68,7 +89,7 @@ async function ensureQwenWorkLogin(options = {}, dependencies = {}) {
     }
   }
   if (options.checkOnly) { return summary(false); }
-  if (isEnvTokenAuthMode(options.env || process.env)) { throw failure('QWENWORK_LOGIN_FAILED'); }
+  if (isEnvTokenAuthMode(env) || isQwenWorkWebRuntime(runtime)) { throw failure('QWENWORK_LOGIN_FAILED'); }
   const result = await (dependencies.login || tokenLogin)(options);
   if (!result || result.ok === false || !result.access_token || !await verify(result, options)) {
     throw failure('QWENWORK_LOGIN_FAILED');

package/lib/core/agent-capabilities.js

@@ -9,7 +9,7 @@ const { buildCommandManifest } = require('./command-manifest');
 const { buildEnvironmentSnapshot } = require('./env');
 const coreUtils = require('./utils');
 const { buildHostAssetCapabilities } = require('../asset/host-capabilities');
-const { buildQwenWorkLoginInvocation } = require('./qwenwork-login-guidance');
+const { buildQwenWorkLoginInvocation, isQwenWorkWebRuntime } = require('./qwenwork-login-guidance');
 const { findProjectRoot, getAuthStatus } = coreUtils;
 
 function redactLogin(login) {
@@ -231,6 +231,18 @@ function buildAuthPath(login, env = process.env, runtime = null) {
       ? 'STOP_AND_REQUEST_ENV_TOKEN'
       : 'RUN_OPENYIDA_LOGIN_IF_USER_APPROVES',
   };
+  if (isQwenWorkWebRuntime(runtime) && !envTokenSession) {
+    const invocation = buildQwenWorkLoginInvocation({ subtype: 'qwenwork_web' });
+    authPath.auth_runtime = 'qwenwork_cloud_exchange';
+    authPath.interactive_login_allowed = true;
+    authPath.missing_token_action = 'RUN_OPENYIDA_LOGIN_QWENWORK';
+    for (const key of ['auth_profile', 'corp_id', 'corp_name', 'user_id', 'user_name', 'store', 'persistence_scope', 'warning']) { delete authPath[key]; }
+    authPath.next_step = authPath.can_auto_use
+      ? 'Silently continue the requested business operation and report its business result.'
+      : 'Run the recommended login command silently. The CLI consumes cloud runtime credentials; do not inspect credentials, open a browser, or fall back to OAuth on failure.';
+    authPath.next_step_commands = authPath.can_auto_use ? [] : [invocation.command];
+    return authPath;
+  }
   // 桌面换票仅由当前活跃宿主和发行配置共同启用，不影响其他宿主的认证路径。
   if (localBeta?.desktopTicketLogin && runtime?.tool === 'qwenwork' && runtime?.subtype === 'qwenwork_desktop' && !envTokenSession) {
     const invocation = buildQwenWorkLoginInvocation();
@@ -247,6 +259,16 @@ function buildAuthPath(login, env = process.env, runtime = null) {
 }
 
 function buildInteractiveLogin(auth, runtime) {
+  if (auth.auth_runtime === 'qwenwork_cloud_exchange' && isQwenWorkWebRuntime(runtime)) {
+    return {
+      mode: 'cloud_token', browser_default: 'not_required', browser_owner: 'none',
+      recommended_command: auth.can_auto_use ? null : buildQwenWorkLoginInvocation({ subtype: 'qwenwork_web' }).command,
+      invocation: buildQwenWorkLoginInvocation({ subtype: 'qwenwork_web' }),
+      agent_action: auth.can_auto_use ? 'continue_business_command' : 'run_login_qwenwork_and_wait',
+      user_visible: false, success_action: 'continue_business_command_without_message',
+      reason: 'qwenwork_web_cloud_credentials', completion_signal: 'process_exit_and_final_json', playwright_required: false,
+    };
+  }
   if (auth.auth_runtime === 'qwenwork_desktop_exchange_ticket' && runtime.tool === 'qwenwork' && runtime.subtype === 'qwenwork_desktop') {
     return {
       mode: 'desktop_ticket', browser_default: 'not_required', browser_owner: 'cli_if_auth_required',
@@ -334,7 +356,7 @@ function buildBuilderPath(login, projectRoot, manifest, env = process.env, runti
     auth,
     runtime,
     interactive_login: buildInteractiveLogin(auth, runtime),
-    communication: runtime.tool === 'qwenwork' && runtime.subtype === 'qwenwork_desktop' ? {
+    communication: isQwenWorkWebRuntime(runtime) || (runtime.tool === 'qwenwork' && runtime.subtype === 'qwenwork_desktop') ? {
       preparation_visibility: 'silent',
       completion_content: 'business_result_and_business_link_only',
       disclose_authentication_identity_environment: false,
@@ -632,7 +654,7 @@ function buildAgentCapabilitiesSummary() {
     schema_version: 1,
     name: 'openyida-agent-capabilities-summary',
     version,
-    login: builderPath.auth.auth_runtime === 'qwenwork_desktop_exchange_ticket'
+    login: ['qwenwork_desktop_exchange_ticket', 'qwenwork_cloud_exchange'].includes(builderPath.auth.auth_runtime)
       ? { status: loginStatus.status, can_auto_use: loginStatus.can_auto_use === true }
       : compactLogin(loginStatus),
     workdir: projectRoot,

package/lib/core/qwenwork-login-guidance.js

@@ -21,12 +21,15 @@ function buildQwenWorkLoginInvocation(options = {}) {
   const executable = resolveExecutable(options.executablePath, options.packageRoot);
   return {
     command: `${executable} login --qwenwork --json`,
-    required_runtime: { tool: 'qwenwork', subtype: 'qwenwork_desktop' },
+    required_runtime: { tool: 'qwenwork', subtype: options.subtype === 'qwenwork_web' ? 'qwenwork_web' : 'qwenwork_desktop' },
     execution: 'command',
     preserve_command_verbatim: true,
     output_visibility: 'internal',
     success_next_step: 'continue_business_operation_silently',
-    failure_next_step: 'follow_returned_invocation_guidance',
+    failure_next_step: options.subtype === 'qwenwork_web' ? 'stop_and_report_blocker_without_browser_or_credentials' : 'follow_returned_invocation_guidance',
   };
 }
-module.exports = { buildQwenWorkLoginInvocation };
+function isQwenWorkWebRuntime(runtime) {
+  return runtime?.tool === 'qwenwork' && runtime?.subtype === 'qwenwork_web';
+}
+module.exports = { buildQwenWorkLoginInvocation, isQwenWorkWebRuntime };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openyida",
-  "version": "2026.10.26-beta.1",
+  "version": "2026.10.26-beta.2",
   "description": "OpenYida CLI - 宜搭低代码 AI 开发工具（安装即用，零配置）",
   "bin": {
     "openyida": "bin/yida-pre-beta.js",
@@ -124,7 +124,7 @@
   "openyidaLocalBeta": {
     "environment": "pre",
     "baseUrl": "https://pre-yida-vpc.alibaba-inc.com",
-    "description": "宜搭 PRE 一次性换票联调",
+    "description": "宜搭 PRE 千问办公免登联调",
     "authDirectory": "qwenwork-pre-beta",
     "desktopTicketLogin": true
   }

package/yida-skills/SKILL.md

@@ -79,6 +79,10 @@ Fast / Plan 选定的主题和主色属于整个应用：导航、原生页、
 
 每项待办对应一个阶段，直接使用上方短标题。创建应用、表单、数据、图片、页面和发布分别展示。执行中保持标题与列表顺序稳定，完成后标记完成并保留记录。图片准备与表单、页面搭建可同时进行，列表顺序仅用于展示。业务细节写在进度消息中，任务编号、命令、路径、授权依据和耗时写入内部执行记录；用户要求的耗时统计集中放入报告。素材采集与应用创建同时进行时，进度描述统一为“素材采集&应用创建”；单独进行时使用对应阶段名称。图片数量、用途及任务详情归入内部执行记录。
 
+## 千问办公网页态的后台登录
+
+当前快照为 `runtime.tool=qwenwork`、`runtime.subtype=qwenwork_web` 且 `interactive_login.mode=cloud_token` 时，按[云端后台免登规则](references/qwenwork-cloud-login.md)执行快照推荐命令。CLI 自动消费沙箱凭据；成功后继续业务，失败不回退浏览器 OAuth，不读取或展示凭据。桌面态继续使用桌面换票。
+
 ## 千问办公桌面端的后台准备
 
 当前快照确认运行于千问办公桌面端时，安装、环境检查和自动登录按[后台准备规则](references/qwenwork-desktop-login.md)静默执行。用户只需要看到业务进度和业务结果。
@@ -100,6 +104,7 @@ Fast / Plan 选定的主题和主色属于整个应用：导航、原生页、
 | `openyida` 不可用 | 先安装或更新 `openyida`，不创建资源 |
 | 工作目录不存在 | 先执行 `openyida copy` 初始化工作目录 |
 | 登录态可用 | 进入 Step 2 |
+| `interactive_login.mode=cloud_token` 且未登录 | 静默执行快照推荐的 `openyida login --qwenwork --json`；CLI 自动消费云端凭据，成功后继续业务；失败停止，不打开浏览器或回退 OAuth |
 | 登录态缺失 | 按快照提示补登录态；未恢复前停止资源写操作 |
 
 千问云端身份接入开发或宿主身份诊断，可显式运行 `openyida auth qwenwork user-info --json`；它只验证千问身份，不建立宜搭登录态，不能据此跳过上述宜搭 auth snapshot 检查。详细边界见 `yida-login`。

package/yida-skills/references/qwenwork-cloud-login.md

@@ -0,0 +1,8 @@
+# 千问办公网页态后台免登
+
+1. 以当前能力快照的 `runtime.tool=qwenwork`、`runtime.subtype=qwenwork_web`、`builder_path.interactive_login.mode=cloud_token` 确认环境。
+2. 已登录直接继续业务；未登录时静默执行快照推荐的命令，通常为 `openyida login --qwenwork --json`，并等待结束。普通 `openyida login` 在该网页态也会自动走同一路径。
+3. CLI 自行消费沙箱提供的 Agent 凭据，兑换千问用户凭据并校验身份，再向当前宜搭环境换取登录态。不要让模型读取、复制、打印环境变量或认证文件。
+4. 成功后直接继续创建应用等用户任务，只展示业务结果和链接；不展示安装、登录、Token、用户、组织、环境或凭据路径。
+5. 缺少凭据、个人身份无企业组织、接口拒绝或网络失败时停止，只简短说明阻塞；不回退 OAuth，不启动浏览器或 Playwright，不要求用户粘贴 Token。
+6. 桌面态仍走桌面换票；其他宿主继续采用其快照中的认证规则；已注入宜搭 Token 的运行环境保持原规则。

package/yida-skills/references/setup-and-env.md

@@ -1,3 +1,7 @@
+## 千问办公网页态的后台登录
+
+当前快照为 `runtime.tool=qwenwork`、`runtime.subtype=qwenwork_web` 且 `interactive_login.mode=cloud_token` 时，按[云端后台免登规则](qwenwork-cloud-login.md)执行快照推荐命令。CLI 自动消费沙箱凭据；成功后继续业务，失败不回退浏览器 OAuth，不读取或展示凭据。桌面态继续使用桌面换票。
+
 ## 千问办公桌面端
 
 当前快照确认运行于千问办公桌面端时，遵循[后台准备规则](qwenwork-desktop-login.md)，静默完成下述准备，不向用户逐项播报。
@@ -23,7 +27,7 @@ openyida login --check-only --json
 - 不要根据 agent 名称、宿主产品、workspace 路径或猜测的环境变量推断认证模式。
 - 先执行 `openyida agent-capabilities --summary-json`；只有简版快照不可用或信息不足时，才降级执行 `openyida login --check-only --json`。
 - snapshot 返回 `login.auth_source=env` 或 `failure_reason=env_token_missing` 时，进入运行环境注入 token 模式。凭证只来自运行环境注入的 `OPENYIDA_ACCESS_TOKEN`、`OPENYIDA_REFRESH_TOKEN` 等环境变量。
-- 其他 `login.auth_mode=token` 场景使用默认 OAuth token session。
+- 除上述千问办公网页态云端免登外，其他 `login.auth_mode=token` 场景使用默认 OAuth token session。
 - 不要从 `.cache/cookies*.json` 推断登录态。
 - OAuth 浏览器归属以 `builder_path.interactive_login.mode` 为准：`not_required` 不触发 OAuth；`cli_auto_open` 执行 `openyida login`；`caller_open_url` 执行 `openyida login --no-browser`，由 Agent 优先调用沙箱浏览器 / 内置 Browser 打开输出 URL 一次；`unsupported` 停止说明环境没有可用浏览器能力，不要默认安装 Playwright。
 
@@ -34,6 +38,7 @@ openyida login --check-only --json
 | command not found | 安装或更新 `openyida`；不要创建资源 |
 | `workdir_exists=false` 或 `active.projectRootExists=false` | 先执行 `openyida copy`；工作目录存在前不要创建资源 |
 | `auth_mode=token` 且 `status=ok` 或 `can_auto_use=true` | 继续执行 |
+| `interactive_login.mode=cloud_token` 且未登录 | 静默执行快照推荐的 `openyida login --qwenwork --json`；CLI 自动消费云端凭据，成功后继续业务；失败停止，不打开浏览器或回退 OAuth |
 | `auth_mode=token` 且 `status=profile_required` | 不猜组织；执行 `openyida auth profiles`，再用 `openyida auth profile switch <auth_profile>` 切换已有 profile |
 | snapshot 返回 `auth_source=env` / `failure_reason=env_token_missing` | 进入运行环境注入 token 模式；缺 token 时停止，让 Codex、yida-agent 等宿主注入 `OPENYIDA_ACCESS_TOKEN` 或 `OPENYIDA_REFRESH_TOKEN`；不要执行 OAuth |
 | `auth_mode=token`，未登录，且 `interactive_login.mode=cli_auto_open` | 只执行一次 `openyida login`，等待该命令结束，并使用其最终 JSON 判断结果 |

package/yida-skills/skills/yida-login/SKILL.md

@@ -11,11 +11,15 @@ description: 宜搭登录态管理。以 OpenYida auth snapshot 为准；默认
 - 不要根据 agent 名称、宿主产品、workspace 路径或猜测的环境变量推断认证模式。
 - 先读 `openyida agent-capabilities --summary-json`；只有需要更多信息时，才降级执行 `openyida login --check-only --json`。
 - snapshot 返回 `login.auth_source=env` 或 `failure_reason=env_token_missing` 时，进入运行环境注入 token 模式。凭证只来自运行环境注入的 `OPENYIDA_ACCESS_TOKEN`、`OPENYIDA_REFRESH_TOKEN` 等环境变量。
-- 其他 `auth_mode=token` 场景使用默认 OAuth token session。
+- 除上述千问办公网页态云端免登外，其他 `auth_mode=token` 场景使用默认 OAuth token session。
 - 不要从 `.cache/cookies*.json` 推断登录态。
 - 浏览器归属以 `builder_path.interactive_login.mode` 为准：`not_required` 不触发 OAuth；`cli_auto_open` 执行 `openyida login` 并等待；`caller_open_url` 执行 `openyida login --no-browser`，由 Agent 优先调用沙箱浏览器 / 内置 Browser 打开 CLI 输出的授权 URL 一次；`unsupported` 停止并说明没有可用浏览器能力，不要默认安装 Playwright。
 - `caller_open_url` 模式下，Agent 不要只把 URL 贴给用户然后等待。只有当前宿主没有浏览器工具，或浏览器工具调用失败时，才退回让用户手动打开 URL。
 
+## 千问办公网页态的后台登录
+
+当前快照为 `runtime.tool=qwenwork`、`runtime.subtype=qwenwork_web` 且 `interactive_login.mode=cloud_token` 时，按[云端后台免登规则](../../references/qwenwork-cloud-login.md)执行快照推荐命令。CLI 自动消费沙箱凭据；成功后继续业务，失败不回退浏览器 OAuth，不读取或展示凭据。桌面态继续使用桌面换票。
+
 ## 千问办公桌面端的后台登录
 
 先以当前快照的 `runtime.tool=qwenwork`、`runtime.subtype=qwenwork_desktop` 和 `builder_path.interactive_login.mode=desktop_ticket` 确认桌面换票能力。满足条件后，按[后台准备规则](../../references/qwenwork-desktop-login.md)静默补齐登录态，随后继续业务操作。
@@ -42,6 +46,7 @@ openyida login --check-only --json
 | 状态 | 动作 |
 |---|---|
 | `auth_mode=token` 且 `status=ok` 或 `can_auto_use=true` | 继续执行业务命令 |
+| `interactive_login.mode=cloud_token` 且未登录 | 静默执行快照推荐的 `openyida login --qwenwork --json`；CLI 自动消费云端凭据，成功后继续业务；失败停止，不打开浏览器或回退 OAuth |
 | `status=profile_required` 且返回 `candidates` / `next_step` | 不猜组织；先执行 `openyida auth profiles`，再用 `openyida auth profile switch <auth_profile>` 切到用户确认或目标匹配的已有 profile |
 | `auth_source=env` / `failure_reason=env_token_missing` | 进入运行环境注入 token 模式；缺 token 时停止，让 Codex、yida-agent 等宿主注入 `OPENYIDA_ACCESS_TOKEN` 或 `OPENYIDA_REFRESH_TOKEN`；不要执行 OAuth |
 | `auth_mode=token`，未登录，且 `interactive_login.mode=cli_auto_open` | 只执行一次 `openyida login`，等待该命令结束，并使用其最终 JSON 判断结果 |