@bsbofmusic/cdper-doubao 1.0.0

package/LICENSE

@@ -0,0 +1,12 @@
+MIT License
+
+Copyright (c) 2026 bsbofmusic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The Software is provided "AS IS", without warranty of any kind.

package/README.md

@@ -0,0 +1,59 @@
+# cdper-doubao
+
+Standalone Doubao CLI for controlling the user's real Chrome/Edge through CDP Bridge.
+
+## Install
+
+```bash
+npm install -g @bsbofmusic/cdper-doubao
+```
+
+Requirements:
+
+- Node.js 18+
+- CDP Bridge running on the user's browser host
+- Doubao logged in in that browser profile
+- CDP WS configured through `CDP_WS`, `~/.cdp-auth.json`, or `~/.cdp-bridge/config.json`
+
+## Use
+
+```bash
+cdper-doubao "1+1等于几？"
+cdper-doubao "请详细解释 TCP keepalive" --json --wait normal
+cdper-doubao doctor --json
+cdper-doubao status --json
+cdper-doubao session --json
+```
+
+Save a CDP WebSocket URL locally:
+
+```bash
+cdper-doubao config set --ws "ws://<host>:<port>/devtools/browser?token=<token>" --json
+```
+
+## Query options
+
+- `--json` - structured JSON output
+- `--mode expert` - Doubao mode path
+- `--session <id>` - continue a known session
+- `--conversation-policy auto|fresh|followup`
+- `--wait short|normal|long|very_long`
+- `--max-wait-ms <ms>`
+- `--progress-every-ms <ms>`
+- `--max-extends <n>`
+- `--no-check` - skip preflight check
+
+## Programmatic API
+
+```js
+const { queryDoubao } = require('@bsbofmusic/cdper-doubao');
+
+const result = await queryDoubao('请用一句话回答：1+1等于几？', {
+  conversationPolicy: 'fresh',
+  expectedDuration: 'short',
+});
+```
+
+## Security
+
+All browser control happens through the user's CDP Bridge. Tokens are redacted from diagnostic output. Do not commit `CDP_WS` or full WebSocket URLs containing `token=`.

package/bin/cdper-doubao.cjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../src/cli.js');

package/manifest.json

@@ -0,0 +1,41 @@
+{
+  "schemaVersion": "1.0",
+  "packageType": "cli",
+  "name": "@bsbofmusic/cdper-doubao",
+  "displayName": "cdper Doubao CLI",
+  "version": "1.0.0",
+  "summary": "Standalone Doubao CLI controlled through a user's real Chrome/Edge via CDP Bridge",
+  "stability": "stable",
+  "publisher": {
+    "type": "official",
+    "vendor": "bsbofmusic"
+  },
+  "capabilities": {
+    "provides": [
+      "plugin.query.chat"
+    ],
+    "requires": [
+      "bridge.browser.tab",
+      "bridge.browser.input",
+      "bridge.browser.extract",
+      "core.run-model"
+    ],
+    "optional": []
+  },
+  "compatibility": {
+    "core": "^1.2.4",
+    "bridgeProtocol": "^1.0.0",
+    "node": ">=18.0.0"
+  },
+  "entrypoints": {
+    "main": "./src/public-api.js",
+    "api": "./src/public-api.js",
+    "bin": "./bin/cdper-doubao.cjs"
+  },
+  "permissions": [],
+  "tags": [
+    "official",
+    "doubao",
+    "cli"
+  ]
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@bsbofmusic/cdper-doubao",
+  "version": "1.0.0",
+  "description": "Standalone Doubao CLI controlled through a user's real Chrome/Edge via CDP Bridge",
+  "type": "commonjs",
+  "main": "src/public-api.js",
+  "exports": {
+    ".": "./src/public-api.js",
+    "./api": "./src/public-api.js"
+  },
+  "bin": {
+    "cdper-doubao": "bin/cdper-doubao.cjs"
+  },
+  "files": [
+    "manifest.json",
+    "src/",
+    "bin/cdper-doubao.cjs"
+  ],
+  "keywords": [
+    "cdp",
+    "doubao",
+    "bytedance",
+    "tailscale",
+    "ai-agent",
+    "cdper",
+    "openclaw"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bsbofmusic/cdper.git",
+    "directory": "plugins/doubao"
+  },
+  "homepage": "https://github.com/bsbofmusic/cdper/tree/main/plugins/doubao#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@bsbofmusic/cdper-core": "^1.2.4",
+    "yargs": "^17.7.2"
+  }
+}

package/src/cli.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+const { fullCheck, formatAgentHints, fullReadiness } = require('@bsbofmusic/cdper-core/check');
+const { getRuntimeStatus } = require('@bsbofmusic/cdper-core/runtime_status');
+const { listSessions, cleanupExpired, closeSession } = require('@bsbofmusic/cdper-core/session');
+const { redactValue } = require('@bsbofmusic/cdper-core/redact');
+const { queryDoubao } = require('./doubao');
+const pkg = require('../package.json');
+
+function writeJson(value) {
+  process.stdout.write(JSON.stringify(redactValue(value), null, 2) + '\n');
+}
+
+function parseQueryOptions(argv) {
+  return {
+    mode: argv.mode || 'expert',
+    sessionId: argv.session,
+    conversationPolicy: argv.conversationPolicy,
+    expectedDuration: argv.wait || argv.expectedDuration,
+    maxWaitMs: argv.maxWaitMs ?? argv.maxWait,
+    progressEveryMs: argv.progressEveryMs,
+    maxExtends: argv.maxExtends,
+  };
+}
+
+async function runQuery(text, argv) {
+  if (!text || !String(text).trim()) throw new Error('Query text is required');
+  if (argv.quiet) process.env.QUIET = '1';
+  if (argv.debug) process.env.DEBUG = '1';
+  if (argv.check !== false) {
+    const check = await fullCheck();
+    if (!check.allPassed) {
+      const failure = { ok: false, error: 'environment_not_ready', check, hints: formatAgentHints(check) };
+      if (argv.json) writeJson(failure); else console.error(failure.hints);
+      process.exit(1);
+    }
+  }
+  const result = await queryDoubao(String(text), parseQueryOptions(argv));
+  if (argv.json) {
+    writeJson(result);
+    return;
+  }
+  if (result.content && String(result.content).trim()) {
+    console.log(result.content);
+    return;
+  }
+  throw new Error('No valid Doubao reply received');
+}
+
+async function runDoctor(argv) {
+  const check = await fullCheck();
+  const readiness = await fullReadiness('doubao').catch((error) => ({ ok: false, error: error.message }));
+  const result = { ok: check.allPassed && readiness.browser === 'ready', version: pkg.version, check, readiness };
+  if (argv.json) writeJson(result);
+  else {
+    console.log(`cdper-doubao ${pkg.version}`);
+    console.log(check.summary);
+    if (!check.allPassed) console.log(formatAgentHints(check));
+    console.log(`Runtime: bridge=${readiness.bridge || 'unknown'} browser=${readiness.browser || 'unknown'} ws=${readiness.ws || 'unknown'}`);
+  }
+  if (!result.ok) process.exit(1);
+}
+
+async function runStatus(argv) {
+  const result = await getRuntimeStatus('doubao');
+  if (argv.json) writeJson(result); else console.log(JSON.stringify(redactValue(result), null, 2));
+  if (!result.ok) process.exit(1);
+}
+
+function runSessions(argv) {
+  const cleaned = cleanupExpired();
+  const sessions = listSessions().filter((s) => s.platform === 'doubao');
+  const result = { ok: true, cleaned, sessions };
+  if (argv.json) writeJson(result);
+  else {
+    console.log(`Doubao sessions (cleaned ${cleaned})`);
+    for (const s of sessions) console.log(`${s.sessionId} turns=${s.turns} ttlMs=${s.ttl}`);
+  }
+}
+
+function runConfigSet(argv) {
+  const ws = String(argv.ws || '').trim();
+  if (!/^ws:\/\//i.test(ws) || !/token=/i.test(ws)) throw new Error('Expected --ws "ws://<host>:<port>/devtools/browser?token=<token>"');
+  const authPath = path.join(os.homedir(), '.cdp-auth.json');
+  fs.writeFileSync(authPath, JSON.stringify({ ws_url: ws }, null, 2) + '\n', { mode: 0o600 });
+  const result = { ok: true, path: authPath, message: 'Saved CDP WS config' };
+  if (argv.json) writeJson(result); else console.log(`Saved ${authPath}`);
+}
+
+function addQueryOptions(cmd) {
+  return cmd
+    .option('json', { type: 'boolean', describe: 'Output JSON' })
+    .option('mode', { alias: 'm', default: 'expert', choices: ['expert'], describe: 'Doubao mode' })
+    .option('session', { alias: 's', type: 'string', describe: 'Session ID' })
+    .option('conversation-policy', { choices: ['auto', 'fresh', 'followup'], default: 'auto', describe: 'Conversation policy' })
+    .option('wait', { choices: ['short', 'normal', 'long', 'very_long'], default: 'normal', describe: 'Wait profile' })
+    .option('expected-duration', { choices: ['short', 'normal', 'long', 'very_long'], describe: 'Alias for --wait' })
+    .option('max-wait-ms', { type: 'number', describe: 'Override max base wait' })
+    .option('max-wait', { type: 'number', describe: 'Alias for --max-wait-ms' })
+    .option('progress-every-ms', { type: 'number', describe: 'Progress snapshot interval' })
+    .option('max-extends', { type: 'number', describe: 'Max 60s wait extensions' })
+    .option('check', { type: 'boolean', default: true, describe: 'Run environment pre-check before query' })
+    .option('quiet', { alias: 'q', type: 'boolean', describe: 'Quiet logs' })
+    .option('debug', { alias: 'd', type: 'boolean', describe: 'Debug logs' });
+}
+
+const rawArgs = hideBin(process.argv);
+const cliArgs = rawArgs[0] === 'query' && rawArgs[1] && !String(rawArgs[1]).startsWith('-')
+  ? rawArgs.slice(1)
+  : rawArgs;
+
+yargs(cliArgs)
+  .scriptName('cdper-doubao')
+  .usage('$0 <query> [options]')
+  .command('$0 <text>', 'Query Doubao', (cmd) => addQueryOptions(cmd.positional('text', { type: 'string', describe: 'Query text' })), async (argv) => runQuery(argv.text, argv).catch(handleError(argv)))
+  .command('doctor', 'Check environment readiness', (cmd) => cmd.option('json', { type: 'boolean' }), async (argv) => runDoctor(argv).catch(handleError(argv)))
+  .command('check', 'Alias for doctor', (cmd) => cmd.option('json', { type: 'boolean' }), async (argv) => runDoctor(argv).catch(handleError(argv)))
+  .command('status', 'Show runtime status', (cmd) => cmd.option('json', { type: 'boolean' }), async (argv) => runStatus(argv).catch(handleError(argv)))
+  .command('session [action] [id]', 'List or close sessions', (cmd) => cmd.positional('action', { type: 'string' }).positional('id', { type: 'string' }).option('json', { type: 'boolean' }), (argv) => {
+    if (argv.action === 'close') {
+      if (!argv.id) return handleError(argv)(new Error('session id is required'));
+      closeSession(argv.id);
+      const r = { ok: true, sessionId: argv.id };
+      if (argv.json) writeJson(r); else console.log(`Closed ${argv.id}`);
+      return;
+    }
+    runSessions(argv);
+  })
+  .command('config set', 'Save CDP WS config', (cmd) => cmd.option('ws', { type: 'string', demandOption: true }).option('json', { type: 'boolean' }), (argv) => { try { runConfigSet(argv); } catch (error) { handleError(argv)(error); } })
+  .command('version', 'Show version', (cmd) => cmd.option('json', { type: 'boolean' }), (argv) => { const r = { ok: true, name: pkg.name, version: pkg.version }; if (argv.json) writeJson(r); else console.log(`${pkg.name} ${pkg.version}`); })
+  .showHelpOnFail(false)
+  .fail((msg, err, yargsInstance) => {
+    const json = rawArgs.includes('--json');
+    const error = err || new Error(msg || 'invalid arguments');
+    if (json) writeJson({ ok: false, error: error.message });
+    else {
+      console.error(error.message);
+      yargsInstance.showHelp('error');
+    }
+    process.exit(1);
+  })
+  .strict()
+  .help()
+  .parse();
+
+function handleError(argv) {
+  return (error) => {
+    const result = { ok: false, error: error.message, cdp: error.cdp || null };
+    if (argv?.json) writeJson(result); else console.error(JSON.stringify(redactValue(result), null, 2));
+    process.exit(1);
+  };
+}

package/src/doubao.js

@@ -0,0 +1,876 @@
+/**
+ * cdper-doubao — 豆包 CDP 查询逻辑
+ * Platform-specific DOM logic only. All shared helpers live in @bsbofmusic/cdper-core/plugin_helpers.
+ */
+const { log } = require('@bsbofmusic/cdper-core/logger');
+const { connectWithWarmReuse, disconnect } = require('@bsbofmusic/cdper-core/cdp');
+const { resolveCdpWs } = require('@bsbofmusic/cdper-core/cdp-ws');
+const { waitForDoubaoReply, captureDoubaoReplySnapshot, detectChallenge } = require('@bsbofmusic/cdper-core/smart_wait');
+const { updateSession } = require('@bsbofmusic/cdper-core/session');
+const { createPluginContext, buildPluginSuccess } = require('@bsbofmusic/cdper-core/plugin_contract');
+const { runState } = require('@bsbofmusic/cdper-core/state_machine');
+const { getRuntimeStatus } = require('@bsbofmusic/cdper-core/runtime_status');
+const { WRAPPER_STATUSES, buildWrapperResult } = require('@bsbofmusic/cdper-core/wrapper_result');
+const {
+  randomInt, humanPause, withLocalTimeout, withAbortableTimeout, throwIfAborted, ensureMinimumPageDwell, humanWarmup,
+  computeSendTimeoutMs, computeTypingDelay, shouldUseDirectTextInsert, insertTextViaCdp,
+  buildWaitPlan, createProgressRecorder,
+  resolveConversationPolicy, buildConversationAnchor,
+  prefersShortAnswer, handlePluginQueryError,
+  verifySubmission,
+} = require('@bsbofmusic/cdper-core/plugin_helpers');
+
+const PLATFORM = 'doubao';
+const STATE_TIMEOUTS = { open: 150000, ensure_session: 30000, ensure_mode: 45000, send: 45000, extract: 10000 };
+const FALLBACK_TIMEOUT_MS = 90000;
+const WAIT_PROFILES = {
+  short:     { minWait: 8000,  maxWait: 90000,          maxExtends: 2,  pollInterval: 2500 },
+  normal:    { minWait: 12000, maxWait: 300000,          maxExtends: 6,  pollInterval: 2500 },
+  long:      { minWait: 20000, maxWait: 20 * 60 * 1000, maxExtends: 8,  pollInterval: 2500 },
+  very_long: { minWait: 30000, maxWait: 45 * 60 * 1000, maxExtends: 10, pollInterval: 2500 },
+};
+
+function directActionMode(mode) {
+  return mode === 'quick' ? 'quick' : 'deep';
+}
+
+function buildDoubaoUrlAction(queryText, mode = 'deep') {
+  const payload = { text: String(queryText || '') };
+  const action = { pluginId: 'Send_Message', payload };
+  if (directActionMode(mode) === 'deep') {
+    payload.extraExt = {
+      input_skill: JSON.stringify({ skill_type: 20 }),
+      use_deep_think: '1',
+    };
+    action.options = {
+      deepThinkingActiveType: '3',
+      superTaskStatus: { switchValue: 0, taskMode: 0, safeToken: '' },
+    };
+  }
+  const url = new URL('https://www.doubao.com/chat/url-action');
+  url.searchParams.set('action', JSON.stringify(action));
+  return url.toString();
+}
+
+function emptyDoubaoSnapshot() {
+  return { text: '', normalized: '', length: 0, candidateCount: 0 };
+}
+
+function buildDoubaoModeState(usedUrlAction, urlActionMode, expertModeConfirmed) {
+  if (usedUrlAction) {
+    return {
+      modePath: urlActionMode === 'quick' ? 'url_action_quick' : 'url_action_deep',
+      modeConfirmed: true,
+      modeConfidence: 'high',
+    };
+  }
+  return {
+    modePath: expertModeConfirmed ? 'composer_expert' : 'composer_quick',
+    modeConfirmed: Boolean(expertModeConfirmed),
+    modeConfidence: expertModeConfirmed ? 'high' : 'low',
+  };
+}
+
+// ─── Conversation anchor ──────────────────────────────────────────────────────
+function isDoubaoUrl(url) {
+  return /doubao\.com/.test(String(url || ''));
+}
+
+function getDoubaoConversationId(url) {
+  const match = String(url || '').match(/https:\/\/(?:www\.)?doubao\.com\/chat\/([^/?#]+)/);
+  if (!match || match[1] === 'url-action') return null;
+  return match[1];
+}
+
+function hasStrongAnchor(session) {
+  const conversation = session?.conversation || {};
+  if (conversation.platform !== PLATFORM || !conversation.anchorUrl) return false;
+  return conversation.anchorConfidence === 'strong' || !!getDoubaoConversationId(conversation.anchorUrl);
+}
+
+function getStoredConversationId(session) {
+  const conversation = session?.conversation || {};
+  return conversation.conversationId || getDoubaoConversationId(conversation.anchorUrl);
+}
+
+function assertFollowupAnchorActive(page, session) {
+  const expectedId = getStoredConversationId(session);
+  const actualId = getDoubaoConversationId(page.url());
+  if (!expectedId || actualId !== expectedId) {
+    throw new Error('Doubao followup anchor was not active after navigation; refusing to send into an unanchored chat');
+  }
+}
+
+// ─── Page readiness ───────────────────────────────────────────────────────────
+async function findDoubaoInput(page) {
+  const handles = await page.$$('textarea, [contenteditable="true"], [role="textbox"]');
+  for (const handle of handles) {
+    try {
+      const box = await handle.boundingBox();
+      if (!box || box.width < 80 || box.height < 20) continue;
+      const meta = await page.evaluate((el) => ({
+        tag: el.tagName, placeholder: el.getAttribute('placeholder') || '',
+        contenteditable: el.getAttribute('contenteditable') || '', role: el.getAttribute('role') || '',
+        disabled: !!el.disabled, ariaHidden: el.getAttribute('aria-hidden') || '',
+      }), handle);
+      if (meta.disabled || meta.ariaHidden === 'true') continue;
+      return { handle, meta };
+    } catch (_) {}
+  }
+  return null;
+}
+
+async function hasDoubaoInput(page, timeoutMs = 12000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const found = await findDoubaoInput(page);
+    if (found) return found;
+    await humanPause(250, 500);
+  }
+  return null;
+}
+
+async function waitForDoubaoPredicate(page, predicate, options = {}) {
+  const { timeoutMs = 12000, intervalMs = 250, stableCount = 1, sessionId, challengeCheck = true } = options;
+  const deadline = Date.now() + timeoutMs;
+  let hits = 0;
+  while (Date.now() < deadline) {
+    if (challengeCheck) await assertNoChallenge(page, sessionId);
+    const matched = await predicate();
+    if (matched) {
+      hits += 1;
+      if (hits >= stableCount) return true;
+    } else hits = 0;
+    await humanPause(intervalMs, intervalMs + 60);
+  }
+  return false;
+}
+
+async function getDoubaoUiState(page) {
+  return page.evaluate(() => {
+    const bodyText = document.body?.innerText || '';
+    const viewportHeight = window.innerHeight || 0;
+    const buttons = Array.from(document.querySelectorAll('button'));
+    const visibleButton = (button) => {
+      const text = (button.innerText || '').trim();
+      const rect = button.getBoundingClientRect();
+      return { text, visible: rect.width >= 28 && rect.height >= 20 && rect.y <= viewportHeight && rect.bottom >= 0 };
+    };
+    const quickButton = buttons.find((button) => {
+      const meta = visibleButton(button);
+      return ['快速', 'Quick'].includes(meta.text) && meta.visible;
+    });
+    const expertButton = buttons.find((button) => /^(?:专家|Expert)($|\n)/.test(visibleButton(button).text) && visibleButton(button).visible);
+    const menu = document.querySelector('[role="menu"]');
+    const menuItems = menu
+      ? Array.from(menu.querySelectorAll('[role="menuitem"]')).map((node) => ({
+          text: (node.innerText || '').trim(),
+          visible: (() => {
+            const rect = node.getBoundingClientRect();
+            return rect.width >= 28 && rect.height >= 20;
+          })(),
+        }))
+      : [];
+    const hasInput = Array.from(document.querySelectorAll('textarea, [contenteditable="true"], [role="textbox"]')).some((element) => {
+      const rect = element.getBoundingClientRect();
+      if (rect.width < 80 || rect.height < 20) return false;
+      const ariaHidden = element.getAttribute('aria-hidden') || '';
+      return ariaHidden !== 'true' && !element.disabled;
+    });
+    const loading = !!document.querySelector('[class*="loading"], [class*="spinner"], [class*="skeleton"]');
+    const unavailable = bodyText.includes('该页面暂时不可用');
+    return { url: location.href, title: document.title || '', hasInput, hasQuickButton: !!quickButton, hasExpertButton: !!expertButton, menuVisible: !!menu, menuItems, loading, unavailable };
+  });
+}
+
+async function waitForDoubaoReady(page, options = {}) {
+  const { timeoutMs = 24000, sessionId } = options;
+  return waitForDoubaoPredicate(page, async () => {
+    const state = await getDoubaoUiState(page);
+    if (state.unavailable) {
+      await recoverDoubaoUnavailablePage(page);
+      return false;
+    }
+    return state.hasInput;
+  }, { timeoutMs, intervalMs: 300, stableCount: 2, sessionId });
+}
+
+async function waitForDoubaoModeSettled(page, options = {}) {
+  const { timeoutMs = 7000, sessionId } = options;
+  return waitForDoubaoPredicate(page, async () => {
+    const state = await getDoubaoUiState(page);
+    return state.hasExpertButton && state.hasInput && !state.menuVisible;
+  }, { timeoutMs, intervalMs: 220, stableCount: 2, sessionId });
+}
+
+async function assertNoChallenge(page, sessionId) {
+  const detected = await detectChallenge(page);
+  if (detected.detected) {
+    log('WARN', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: sessionId, step: 'gate', action: 'challenge_detect', status: 'blocked', message: '命中风控/验证页: ' + detected.hint });
+    throw new Error('命中风控/验证页，需要人工接管: ' + detected.hint);
+  }
+}
+
+// ─── Navigation helpers ───────────────────────────────────────────────────────
+async function adoptExistingDoubaoPage(browser, fallbackPage) {
+  try {
+    const pages = await browser.pages();
+    for (const candidate of pages) {
+      try {
+        const url = candidate.url();
+        if (isDoubaoUrl(url) && candidate !== fallbackPage) {
+          await candidate.bringToFront();
+          try { await fallbackPage.close(); } catch (_) {}
+          candidate.__cdperManagedPage = false;
+          return candidate;
+        }
+      } catch (_) {}
+    }
+  } catch (_) {}
+  return fallbackPage;
+}
+
+async function clickHandleWithoutCoordinates(handle, label) {
+  try {
+    await withLocalTimeout(handle.evaluate((element) => element.click()), label + ' DOM click');
+    return true;
+  } catch (error) { log('WARN', '[doubao]', label + 'DOM click 失败，尝试键盘激活: ' + error.message); }
+
+  try {
+    await withLocalTimeout((async () => {
+      await handle.focus();
+      await humanPause(80, 140);
+      await handle.press('Enter');
+    })(), label + ' keyboard activate');
+    return true;
+  } catch (error) { log('WARN', '[doubao]', label + '键盘激活失败，尝试句柄点击: ' + error.message); }
+
+  try {
+    await withLocalTimeout(handle.click({ delay: 80 }), label + ' handle click');
+    return true;
+  } catch (error) { log('WARN', '[doubao]', label + '句柄点击失败: ' + error.message); }
+  return false;
+}
+
+async function clickButtonByExactText(page, text, label) {
+  try {
+    const clicked = await page.evaluate((targetText) => {
+      const button = Array.from(document.querySelectorAll('button')).find((node) => {
+        const nodeText = (node.innerText || '').trim();
+        const rect = node.getBoundingClientRect();
+        return nodeText === targetText && rect.width > 0 && rect.height > 0;
+      });
+      if (!button) return false;
+      button.click();
+      return true;
+    }, text);
+    if (clicked) return true;
+  } catch (error) { log('WARN', '[doubao]', label + '页面级点击失败: ' + error.message); }
+  return false;
+}
+
+async function clickMenuItemByPrefix(page, prefix, label) {
+  try {
+    const clicked = await page.evaluate((targetPrefix) => {
+      const menu = document.querySelector('[role="menu"]');
+      if (!menu) return false;
+      const item = Array.from(menu.querySelectorAll('[role="menuitem"]')).find((node) => {
+        const text = (node.innerText || '').trim();
+        const rect = node.getBoundingClientRect();
+        return text.startsWith(targetPrefix) && rect.width > 0 && rect.height > 0;
+      });
+      if (!item) return false;
+      item.click();
+      return true;
+    }, prefix);
+    if (clicked) return true;
+  } catch (error) { log('WARN', '[doubao]', label + '页面级点击失败: ' + error.message); }
+  return false;
+}
+
+async function recoverDoubaoUnavailablePage(page) {
+  try {
+    const refreshState = await page.evaluate(() => {
+      const bodyText = document.body?.innerText || '';
+      if (!bodyText.includes('该页面暂时不可用')) return { found: false, reload: false };
+      const hasRefreshButton = Array.from(document.querySelectorAll('button')).some((button) => {
+        const text = (button.innerText || '').trim();
+        const rect = button.getBoundingClientRect();
+        return text.includes('刷新页面') && rect.width > 0 && rect.height > 0;
+      });
+      return { found: true, reload: !hasRefreshButton };
+    });
+
+    if (!refreshState.found) return false;
+    if (refreshState.reload) {
+      await page.reload({ timeout: 60000, waitUntil: 'domcontentloaded' });
+    } else {
+      const buttons = await page.$$('button');
+      let clicked = false;
+      for (const button of buttons) {
+        const text = await button.evaluate((element) => (element.innerText || '').trim()).catch(() => '');
+        if (!text.includes('刷新页面')) continue;
+        clicked = await clickHandleWithoutCoordinates(button, '刷新页面按钮');
+        if (clicked) break;
+      }
+      if (!clicked) await page.reload({ timeout: 60000, waitUntil: 'domcontentloaded' });
+    }
+    await humanPause(2500, 5000);
+    return true;
+  } catch (_) { return false; }
+}
+
+async function openDoubaoHome(page, sessionId) {
+  let lastError = null;
+  if (isDoubaoUrl(page.url())) {
+    await humanWarmup(page);
+    await recoverDoubaoUnavailablePage(page);
+    if (await waitForDoubaoReady(page, { timeoutMs: 5000, sessionId })) return true;
+  }
+
+  for (const url of ['https://www.doubao.com/', 'https://www.doubao.com/chat/']) {
+    try {
+      await page.goto(url, { timeout: 60000, waitUntil: 'domcontentloaded' });
+      await humanWarmup(page);
+      await recoverDoubaoUnavailablePage(page);
+      if (await waitForDoubaoReady(page, { timeoutMs: 24000, sessionId })) return true;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  if (lastError) throw lastError;
+  throw new Error('Doubao 页面未准备好：输入框未出现');
+}
+
+async function getDoubaoDirectState(page) {
+  return page.evaluate(() => {
+    const bodyText = document.body?.innerText || '';
+    const inputs = Array.from(document.querySelectorAll('textarea, [contenteditable="true"], [role="textbox"]'));
+    const input = inputs.find((element) => {
+      const rect = element.getBoundingClientRect();
+      return rect.width >= 80 && rect.height >= 20 && element.getAttribute('aria-hidden') !== 'true' && !element.disabled;
+    });
+    const inputText = String(input?.value || input?.innerText || input?.textContent || '').trim();
+    const stopButton = Array.from(document.querySelectorAll('button')).find((button) => {
+      const text = button.innerText || '';
+      const aria = button.getAttribute('aria-label') || '';
+      return /停止|stop/i.test(`${text} ${aria}`);
+    });
+    const loading = document.querySelector('[class*="loading"], [class*="spinner"], [class*="skeleton"]');
+    const replyContainers = Array.from(document.querySelectorAll('[class*="flow-markdown-body"], [class*="container-P2rR72"], [class*="mdbox-theme"], [class*="message"], [class*="response"], [class*="answer"], .prose'))
+      .filter((element) => {
+        const cls = String(element.className || '');
+        if (/message-list|suggest|recommend|bg-g-send/i.test(cls)) return false;
+        const rect = element.getBoundingClientRect();
+        const text = (element.innerText || '').trim();
+        return rect.width > 0 && rect.height > 0 && text && !/历史对话|内容由豆包 AI 生成/.test(text);
+      });
+    return {
+      url: location.href,
+      title: document.title || '',
+      bodySample: bodyText.slice(0, 1200),
+      hasInput: !!input,
+      inputText,
+      isGenerating: !!stopButton || !!loading,
+      candidateCount: replyContainers.length,
+      unavailable: bodyText.includes('该页面暂时不可用'),
+    };
+  });
+}
+
+async function openDoubaoUrlAction(page, queryText, mode, sessionId) {
+  const targetUrl = buildDoubaoUrlAction(queryText, mode);
+  await page.goto(targetUrl, { timeout: 60000, waitUntil: 'domcontentloaded' });
+  await humanPause(1800, 3800);
+  await recoverDoubaoUnavailablePage(page);
+  await assertNoChallenge(page, sessionId);
+  const deadline = Date.now() + 30000;
+  let state = null;
+  while (Date.now() < deadline) {
+    state = await getDoubaoDirectState(page);
+    if (state.unavailable) await recoverDoubaoUnavailablePage(page);
+    if (state.candidateCount > 0 || state.isGenerating) return { accepted: true, needsManualSubmit: false, state, url: targetUrl };
+    if (state.hasInput && state.inputText) return { accepted: false, needsManualSubmit: true, state, url: targetUrl };
+    await humanPause(400, 800);
+  }
+  state = state || await getDoubaoDirectState(page).catch(() => null);
+  return { accepted: false, needsManualSubmit: true, state, url: targetUrl };
+}
+
+async function hasDoubaoConversationContent(page) {
+  const snapshot = await captureDoubaoReplySnapshot(page).catch(() => null);
+  return Number(snapshot?.length || 0) > 0;
+}
+
+async function ensureFreshDoubaoHome(page, sessionId) {
+  await openDoubaoHome(page, sessionId);
+  const hasExistingContent = await hasDoubaoConversationContent(page);
+  const isConversationUrl = !!getDoubaoConversationId(page.url());
+  if (hasExistingContent || isConversationUrl) {
+    await clickNewChat(page, { strict: true, sessionId });
+    await humanPause(900, 1800);
+  }
+  await assertNoChallenge(page, sessionId);
+  if (!(await waitForDoubaoReady(page, { timeoutMs: 12000, sessionId }))) {
+    throw new Error('Doubao fresh conversation input was not ready');
+  }
+  if (await hasDoubaoConversationContent(page)) {
+    throw new Error('Doubao fresh conversation could not be confirmed clean');
+  }
+  return true;
+}
+
+// ─── Input helpers ────────────────────────────────────────────────────────────
+async function typeIntoDoubaoInput(page, inputHandle, text) {
+  await inputHandle.focus();
+  await humanPause(160, 420);
+  const value = String(text || '');
+  if (shouldUseDirectTextInsert(value)) {
+    await insertTextViaCdp(page, value);
+    return;
+  }
+  await page.keyboard.type(value, { delay: computeTypingDelay(value) });
+}
+
+async function clickDoubaoSend(page) {
+  const candidates = await page.$$('button,[role="button"]');
+  for (const handle of candidates) {
+    const meta = await handle.evaluate((element) => {
+      const text = (element.innerText || '').trim();
+      const aria = element.getAttribute('aria-label') || '';
+      const disabled = element.disabled || element.getAttribute('aria-disabled') === 'true';
+      const rect = element.getBoundingClientRect();
+      return { text, aria, disabled, visible: rect.width > 0 && rect.height > 0 };
+    }).catch(() => null);
+    if (!meta || meta.disabled || !meta.visible) continue;
+    const looksLikeSend = [meta.text, meta.aria].some((value) => /发送|提交|send/i.test(value));
+    if (looksLikeSend) return clickHandleWithoutCoordinates(handle, '发送按钮');
+  }
+  return false;
+}
+
+async function clearDoubaoInput(page, inputHandle) {
+  await inputHandle.focus();
+  await humanPause(100, 220);
+  const modifier = process.platform === 'darwin' ? 'Meta' : 'Control';
+  try { await page.keyboard.down(modifier); await page.keyboard.press('A'); await page.keyboard.up(modifier); } catch (_) {}
+  await humanPause(60, 160);
+  try { await page.keyboard.press('Backspace'); } catch (_) {}
+  await humanPause(80, 180);
+}
+
+async function clickNewChat(page, options = {}) {
+  const { strict = false, sessionId } = options;
+  try {
+    const handles = await page.$$('button,[role="button"],div,span,a');
+    let target = null;
+    for (const handle of handles) {
+      const meta = await handle.evaluate((el) => {
+        const text = (el.innerText || '').trim();
+        const rect = el.getBoundingClientRect();
+        return { text, x: rect.x, y: rect.y, w: rect.width, h: rect.height };
+      }).catch(() => null);
+      if (!meta || !['新对话', '新聊天', 'New chat'].includes(meta.text)) continue;
+      if (meta.w <= 0 || meta.h <= 0) continue;
+      target = handle;
+      break;
+    }
+
+    if (target) {
+      await clickHandleWithoutCoordinates(target, '新对话按钮');
+      log('DEBUG', '[doubao]', '已点击新对话');
+      return true;
+    }
+    if (strict) {
+      log('WARN', '[doubao]', '未找到新对话按钮，严格 fresh 模式下重新打开首页');
+      await page.goto('https://www.doubao.com/', { timeout: 60000, waitUntil: 'domcontentloaded' });
+      await humanPause(900, 1800);
+      return waitForDoubaoReady(page, { timeoutMs: 12000, sessionId });
+    }
+    const input = await hasDoubaoInput(page, 4000);
+    if (input) {
+      log('WARN', '[doubao]', '未找到新对话按钮，但输入框可用，保留当前页面继续');
+      return false;
+    }
+    log('WARN', '[doubao]', '未找到新对话按钮，重新打开首页');
+    await openDoubaoHome(page, sessionId);
+    return false;
+  } catch (e) { log('WARN', '[doubao]', '新建对话失败: ' + e.message); return false; }
+}
+
+async function switchToExpert(page, sessionId) {
+  const isExpertButton = async () => (await getDoubaoUiState(page)).hasExpertButton;
+
+  if (await isExpertButton()) { log('INFO', '[doubao]', '专家按钮已存在，模式已就绪'); return true; }
+
+  const findQuickButtons = async () => {
+    const btns = await page.$$('button');
+    let trigger = null;
+    let fallback = null;
+    for (const btn of btns) {
+      const meta = await btn.evaluate((el) => ({
+        text: (el.innerText || '').trim(), ariaHasPopup: el.getAttribute('aria-haspopup') || '',
+        dataSlot: el.getAttribute('data-slot') || '', dataState: el.getAttribute('data-state') || '',
+      })).catch(() => null);
+      if (!meta || meta.text !== '快速') continue;
+      if (meta.ariaHasPopup === 'menu' || meta.dataSlot === 'dropdown-menu-trigger') {
+        trigger = btn;
+        break;
+      }
+      if (!fallback) fallback = btn;
+    }
+    return { trigger, fallback };
+  };
+
+  const waitForExpertMenu = () => waitForDoubaoPredicate(page, async () => {
+    const state = await getDoubaoUiState(page);
+    return state.menuVisible && state.menuItems.some((item) => /^专家($|\n)/.test(item.text));
+  }, { timeoutMs: 5000, intervalMs: 180, stableCount: 1, challengeCheck: false });
+
+  const openQuickMenu = async (attempt) => {
+    const { trigger, fallback } = await findQuickButtons();
+    const candidates = [
+      { handle: trigger, label: '快速菜单触发器(第' + attempt + '次)' },
+      { handle: fallback, label: '快速按钮候选(第' + attempt + '次)' },
+    ].filter((item) => item.handle);
+    const activate = async (handle, key) => {
+      try { await handle.focus(); await humanPause(80, 140); await handle.press(key); return waitForExpertMenu().catch(() => false); } catch (_) { return false; }
+    };
+
+    for (const candidate of candidates) {
+      const clicked = await clickHandleWithoutCoordinates(candidate.handle, candidate.label);
+      if (clicked && await waitForExpertMenu().catch(() => false)) return true;
+      if (await activate(candidate.handle, 'ArrowDown')) return true;
+      if (await activate(candidate.handle, 'Enter')) return true;
+    }
+
+    return (await clickButtonByExactText(page, '快速', '快速按钮(第' + attempt + '次)')) && await waitForExpertMenu().catch(() => false);
+  };
+
+  const clickExpertInMenu = async () => {
+    if (await clickMenuItemByPrefix(page, '专家', '专家菜单项')) return true;
+    const menu = await page.$('[role="menu"]');
+    if (!menu) return false;
+    const items = await menu.$$('[role="menuitem"]');
+    for (const item of items) {
+      const text = await item.evaluate((el) => (el.innerText || '').trim()).catch(() => '');
+      if (!/^专家($|\n)/.test(text)) continue;
+      if (await clickHandleWithoutCoordinates(item, '专家菜单项')) return true;
+    }
+    return false;
+  };
+
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    const { trigger, fallback } = await findQuickButtons();
+    if (!trigger && !fallback) {
+      log('WARN', '[doubao]', '未找到快速按钮');
+      return false;
+    }
+
+    if (!(await openQuickMenu(attempt))) {
+      log('WARN', '[doubao]', '点击快速后菜单未出现，第' + attempt + '次重试');
+      continue;
+    }
+
+    if (!(await clickExpertInMenu())) {
+      const state = await getDoubaoUiState(page).catch(() => ({ menuItems: [] }));
+      log('WARN', '[doubao]', '未在菜单中找到专家项: ' + JSON.stringify((state.menuItems || []).map((item) => item.text)));
+      continue;
+    }
+
+    const settled = await waitForDoubaoModeSettled(page, { timeoutMs: 7000, sessionId }).catch(() => false);
+    if (settled) {
+      log('INFO', '[doubao]', '专家模式切换成功');
+      return true;
+    }
+
+    const inputStable = await waitForDoubaoReady(page, { timeoutMs: 5000, sessionId }).catch(() => false);
+    if (inputStable && await isExpertButton()) {
+      log('INFO', '[doubao]', '专家模式切换成功，输入区稳定');
+      return true;
+    }
+  }
+
+  log('WARN', '[doubao]', '专家模式切换未能确认成功');
+  return false;
+}
+
+// ─── Main query ───────────────────────────────────────────────────────────────
+async function queryDoubao(queryText, opts = {}) {
+  const { mode = 'expert', sessionId, _retried = false, _quickFallback = false } = opts;
+  const abortSignal = opts.abortSignal || null;
+  const fallbackMeta = opts._fallbackMeta || null;
+  throwIfAborted(abortSignal, 'Doubao query');
+  const hasExplicitSession = Boolean(sessionId);
+  const queryPreview = String(queryText || '').slice(0, 50);
+  log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: sessionId || '', step: 'query', action: 'start', status: 'ok', message: '查询: "' + queryPreview + '..." [mode=' + mode + ']' });
+
+  const { session, flow } = createPluginContext('doubao', PLATFORM, sessionId);
+  const conversationPlan = resolveConversationPolicy(opts, session, hasExplicitSession, hasStrongAnchor);
+  if (conversationPlan.effective === 'followup' && !hasStrongAnchor(session)) {
+    throw new Error('Doubao followup requires an existing conversation anchor for this sessionId');
+  }
+  const waitPlan = buildWaitPlan(opts, WAIT_PROFILES);
+  const progressRecorder = createProgressRecorder('doubao', opts);
+  let activeSession = session;
+  let initialReplySnapshot = null;
+  let inputReadyAfterOpen = false;
+  let promptSubmitted = false;
+  let usedUrlAction = false;
+  let urlActionNeedsManualSubmit = false;
+  let urlActionMode = directActionMode(mode);
+  let expertModeConfirmed = false;
+  let page, browser;
+
+  try {
+    throwIfAborted(abortSignal, 'Doubao query');
+    await runState(flow, 'open', async () => {
+      throwIfAborted(abortSignal, 'Doubao open');
+      const wantsFreshPage = conversationPlan.effective === 'fresh';
+      const connected = await connectWithWarmReuse({
+        wsUrl: resolveCdpWs(),
+        preferHost: 'doubao.com',
+        prewarmUrl: 'https://www.doubao.com/',
+        titleHint: '豆包',
+        mode: 'advanced',
+        profile: 'Default',
+        forceNewPage: wantsFreshPage,
+        waitMs: randomInt(800, 1600),
+      });
+      page = connected.page;
+      browser = connected.browser;
+      // Fresh queries should start from a fresh tab instead of adopting a stale
+      // conversation that happens to share the same host.
+      if (!connected.reusedExistingPage && !wantsFreshPage) page = await adoptExistingDoubaoPage(browser, page);
+
+      if (conversationPlan.effective === 'followup') {
+        inputReadyAfterOpen = await openDoubaoHome(page, session.sessionId);
+        const anchorUrl = session.conversation?.anchorUrl;
+        if (anchorUrl && page.url() !== anchorUrl) {
+          await page.goto(anchorUrl, { timeout: 60000, waitUntil: 'domcontentloaded' });
+          await humanPause(900, 1800);
+          await assertNoChallenge(page, session.sessionId);
+          assertFollowupAnchorActive(page, session);
+          inputReadyAfterOpen = await waitForDoubaoReady(page, { timeoutMs: 24000, sessionId: session.sessionId });
+          if (!inputReadyAfterOpen) throw new Error('Doubao followup anchor opened but input was not ready');
+        }
+        assertFollowupAnchorActive(page, session);
+      } else if (conversationPlan.effective === 'fresh') {
+        // Fresh Doubao queries use the official URL action entrypoint. It
+        // submits the prompt server-side and enables deep thinking without
+        // brittle menu switching. The legacy composer path remains for
+        // anchored followups and rare manual-submit fallback.
+        initialReplySnapshot = emptyDoubaoSnapshot();
+        const direct = await openDoubaoUrlAction(page, queryText, urlActionMode, session.sessionId);
+        usedUrlAction = true;
+        urlActionNeedsManualSubmit = direct.needsManualSubmit;
+        inputReadyAfterOpen = Boolean(direct.state?.hasInput || direct.accepted);
+        promptSubmitted = direct.accepted;
+        if (!inputReadyAfterOpen) throw new Error('Doubao url-action did not prepare a prompt or conversation');
+      } else {
+        inputReadyAfterOpen = await openDoubaoHome(page, session.sessionId);
+      }
+
+      page.__cdperManagedPage = false;
+      await ensureMinimumPageDwell(Date.now(), 'doubao');
+    }, { timeoutMs: STATE_TIMEOUTS.open, retries: 1, retryable: (error) => /页面未准备好|输入框未出现|STATE_TIMEOUT/.test(String(error.message || '') + ' ' + String(error.code || '')) });
+    log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'flow', action: 'stage_complete', stage: 'open', status: 'ok' });
+
+    throwIfAborted(abortSignal, 'Doubao query');
+    await runState(flow, 'ensure_session', async () => {
+      if (usedUrlAction && promptSubmitted) return;
+      if (inputReadyAfterOpen && await hasDoubaoInput(page, 1800)) return;
+      const existingInput = await hasDoubaoInput(page, 12000);
+      if (!existingInput) {
+        if (conversationPlan.effective === 'followup') {
+          throw new Error('Doubao followup anchor opened but input was not ready; refusing to start a fresh chat');
+        }
+        await clickNewChat(page, { sessionId: session.sessionId });
+      }
+      if (!(await waitForDoubaoReady(page, { timeoutMs: 12000, sessionId: session.sessionId }))) {
+        throw new Error('Doubao 输入框未就绪');
+      }
+    }, { timeoutMs: STATE_TIMEOUTS.ensure_session });
+    log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'flow', action: 'stage_complete', stage: 'ensure_session', status: 'ok' });
+
+    throwIfAborted(abortSignal, 'Doubao query');
+    expertModeConfirmed = await runState(flow, 'ensure_mode', async () => {
+      if (usedUrlAction) return false;
+      const confirmed = await switchToExpert(page, session.sessionId);
+      await assertNoChallenge(page, session.sessionId);
+      if (confirmed) await waitForDoubaoModeSettled(page, { timeoutMs: 6000, sessionId: session.sessionId }).catch(() => false);
+      return confirmed;
+    }, { timeoutMs: STATE_TIMEOUTS.ensure_mode });
+    log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'flow', action: 'stage_complete', stage: 'ensure_mode', status: 'ok', ...buildDoubaoModeState(usedUrlAction, urlActionMode, expertModeConfirmed), ...(usedUrlAction ? {} : { expertModeConfirmed }) });
+    if (!usedUrlAction && !expertModeConfirmed) {
+      log('WARN', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'mode', action: 'expert_confirm', status: 'blocked', message: '未确认进入专家模式，停止发送以避免错误模式输出' });
+      throw new Error('Doubao 专家模式未确认，需要人工接管');
+    }
+
+    throwIfAborted(abortSignal, 'Doubao query');
+    await runState(flow, 'send', async () => {
+      if (usedUrlAction) {
+        if (!initialReplySnapshot) initialReplySnapshot = emptyDoubaoSnapshot();
+        if (promptSubmitted && !urlActionNeedsManualSubmit) {
+          flow.enter('send', { submitVerified: true, submitSignal: 'url_action_accepted', submitElapsed: 0, mode: urlActionMode });
+          log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'query', action: 'submit', status: 'ok', message: '问题已通过 url-action 发送' });
+          return;
+        }
+      }
+      const input = await hasDoubaoInput(page, 18000);
+      if (!input) throw new Error('Doubao 输入框未就绪');
+      await assertNoChallenge(page, session.sessionId);
+      if (!usedUrlAction) {
+        initialReplySnapshot = await captureDoubaoReplySnapshot(page).catch(() => null);
+        await clearDoubaoInput(page, input.handle);
+        await typeIntoDoubaoInput(page, input.handle, queryText);
+      } else {
+        await input.handle.focus();
+      }
+      await assertNoChallenge(page, session.sessionId);
+      await humanPause(900, 1800);
+      const clicked = await clickDoubaoSend(page);
+      if (!clicked) await page.keyboard.press('Enter');
+      await assertNoChallenge(page, session.sessionId);
+      await humanPause(350, 900);
+      promptSubmitted = true;
+
+      // P1-3: Verify submission was accepted
+      const submitVerify = await verifySubmission(page, {
+        timeoutMs: 15000,
+        pollIntervalMs: 500,
+        baselineSnapshot: initialReplySnapshot,
+        captureUserTurn: async (page, baseline) => {
+          const baselineCount = Number(baseline?.candidateCount || 0);
+          return page.evaluate((bc) => {
+            // Doubao: check if number of visible reply containers increased
+            const replyContainers = document.querySelectorAll('[class*="flow-markdown-body"], [class*="container-P2rR72"]');
+            return replyContainers.length > bc;
+          }, baselineCount);
+        },
+        captureInputCleared: async (page) => {
+          return page.evaluate(() => {
+            const textarea = document.querySelector('textarea') || document.querySelector('[contenteditable="true"]');
+            if (!textarea) return false;
+            const val = textarea.value || textarea.innerText || '';
+            return val.trim().length <= 5; // allow very short residual whitespace
+          });
+        },
+        captureGenerating: async (page) => {
+          return page.evaluate(() => {
+            const stopBtn = Array.from(document.querySelectorAll('button')).find(
+              (b) => b.innerText?.includes('停止') || b.getAttribute('aria-label')?.includes('stop')
+            );
+            const loading = document.querySelector('[class*="loading"]') || document.querySelector('[class*="skeleton"]');
+            return !!stopBtn || !!loading;
+          });
+        },
+      });
+
+      if (!submitVerify.accepted) {
+        flow.enter('send', { submitVerified: false, submitElapsed: submitVerify.elapsed });
+        const error = new Error('Doubao 消息未成功提交 (send_not_accepted)');
+        error.code = 'SEND_NOT_ACCEPTED';
+        throw error;
+      }
+
+      flow.enter('send', { submitVerified: true, submitSignal: submitVerify.signal, submitElapsed: submitVerify.elapsed });
+      log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'query', action: 'submit', status: 'ok', message: '问题已发送' });
+    }, { timeoutMs: computeSendTimeoutMs(queryText, STATE_TIMEOUTS.send) });
+
+    const result = await runState(flow, 'wait', () => waitForDoubaoReply(page, {
+      query: queryText, abortSignal, minWait: waitPlan.minWait, maxWait: waitPlan.maxWait, pollInterval: waitPlan.pollInterval,
+      stableThreshold: 4, enableCircuitBreaker: true, enableExtend: true, maxExtends: waitPlan.maxExtends,
+      acceptShortContent: prefersShortAnswer(queryText), minShortContentLength: 1,
+      onProgress: progressRecorder.onProgress, challengeCheckIntervalMs: 6000, initialReplySnapshot,
+    }), { timeoutMs: waitPlan.stateTimeoutMs });
+
+    if (!result?.content) throw new Error('未获取到有效回复');
+    const wrapperStatus = result.wrapperStatus || result.exitReason;
+    if ([WRAPPER_STATUSES.CAPTCHA_REQUIRED, WRAPPER_STATUSES.CIRCUIT_BREAKER, 'challenge', 'circuit_breaker'].includes(wrapperStatus)) {
+      throw new Error('查询被阻断，需要人工接管: ' + wrapperStatus + (result.detectedChallenge ? ' (' + result.detectedChallenge + ')' : ''));
+    }
+
+    const completenessScore = result.completeness?.score || 0;
+    const contentMarkedIncomplete = result.completeness?.isComplete === false;
+    if (!_quickFallback && conversationPlan.effective === 'fresh' && usedUrlAction && urlActionMode === 'deep' && completenessScore < 70 && contentMarkedIncomplete && !prefersShortAnswer(queryText)) {
+      log('WARN', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'query', action: 'fallback', status: 'degraded', message: 'deep url-action produced low-completeness content; retrying quick url-action (score=' + completenessScore + ')' });
+      if (page || browser) await disconnect(page, browser).catch(() => undefined);
+      page = null;
+      browser = null;
+      return await withAbortableTimeout(
+        (signal) => queryDoubao(queryText, { ...opts, mode: 'quick', conversationPolicy: 'fresh', _quickFallback: true, abortSignal: signal, _fallbackMeta: { attempted: true, fromMode: urlActionMode, toMode: 'quick', reason: 'low_completeness', timeoutMs: FALLBACK_TIMEOUT_MS } }),
+        'quick url-action fallback',
+        FALLBACK_TIMEOUT_MS
+      );
+    }
+
+    if (wrapperStatus === WRAPPER_STATUSES.PARTIAL_TIMEOUT && result.content) {
+      return buildWrapperResult({
+        status: WRAPPER_STATUSES.PARTIAL_TIMEOUT,
+        content: result.content,
+        exitReason: result.exitReason,
+        diagnostics: { pillars: result.pillars, completeness: result.completeness },
+        platform: 'doubao',
+      });
+    }
+
+    activeSession = await runState(flow, 'extract', async () => {
+      const conversation = buildConversationAnchor(PLATFORM, page.url(), getDoubaoConversationId, conversationPlan.effective);
+      return updateSession(session.sessionId, { turns: session.turns + 1, conversation });
+    }, { timeoutMs: STATE_TIMEOUTS.extract });
+
+    const modeState = buildDoubaoModeState(usedUrlAction, urlActionMode, expertModeConfirmed);
+    const contentIsComplete = result.completeness?.isComplete === true;
+    const finalStatus = ['complete', 'complete_short'].includes(result.exitReason) && contentIsComplete ? 'ok' : 'degraded';
+    log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'query', action: 'complete', status: finalStatus, message: '回复完成：' + result.content.length + ' 字，完整度 ' + (result.completeness?.score || 0) + '分，exitReason=' + (result.exitReason || 'unknown') });
+
+    return buildPluginSuccess({
+      pluginName: 'doubao',
+      session: activeSession,
+      flow,
+      runtimeStatus: await getRuntimeStatus('doubao'),
+      doneMeta: { status: finalStatus, turn: activeSession.turns, ...modeState, ...(usedUrlAction ? {} : { expertModeConfirmed }), usedUrlAction, urlActionMode: usedUrlAction ? urlActionMode : null, conversationPolicy: conversationPlan.effective },
+      payload: {
+        content: result.content,
+        score: completenessScore,
+        completeness: result.completeness || null,
+        status: finalStatus,
+        fallback: fallbackMeta,
+        exitReason: result.exitReason || 'unknown',
+        ...modeState,
+        ...(usedUrlAction ? {} : { expertModeConfirmed }),
+        usedUrlAction,
+        urlActionMode: usedUrlAction ? urlActionMode : null,
+        detectedChallenge: result.detectedChallenge || null,
+        conversationPolicy: conversationPlan.requested,
+        effectiveConversationPolicy: conversationPlan.effective,
+        conversation: activeSession.conversation || null,
+        waitPlan: { expectedDuration: waitPlan.expectedDuration, minWait: waitPlan.minWait, maxWait: waitPlan.maxWait, maxExtends: waitPlan.maxExtends, pollInterval: waitPlan.pollInterval, elapsed: result.elapsed, extendCount: result.extendCount },
+        progress: progressRecorder.events,
+      },
+    });
+  } catch (error) {
+    if (!_quickFallback && error.code !== 'FALLBACK_TIMEOUT' && conversationPlan.effective === 'fresh' && usedUrlAction && urlActionMode === 'deep') {
+      log('WARN', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'query', action: 'fallback', status: 'degraded', message: 'deep url-action failed; retrying quick url-action: ' + error.message });
+      if (page || browser) await disconnect(page, browser).catch(() => undefined);
+      page = null;
+      browser = null;
+      return await withAbortableTimeout(
+        (signal) => queryDoubao(queryText, { ...opts, mode: 'quick', conversationPolicy: 'fresh', _quickFallback: true, abortSignal: signal, _fallbackMeta: { attempted: true, fromMode: urlActionMode, toMode: 'quick', reason: error.message, timeoutMs: FALLBACK_TIMEOUT_MS } }),
+        'quick url-action fallback',
+        FALLBACK_TIMEOUT_MS
+      );
+    }
+    return handlePluginQueryError(error, {
+      flow, pluginName: 'doubao', retried: _retried,
+      retryFn: () => queryDoubao(queryText, { ...opts, _retried: true }),
+      failedMeta: { error: error.message, conversationPolicy: conversationPlan.effective, promptSubmitted },
+    });
+  } finally {
+    if (page || browser) await disconnect(page, browser);
+  }
+}
+
+module.exports = { queryDoubao };

package/src/public-api.js

@@ -0,0 +1,16 @@
+const manifest = require('../manifest.json');
+const { queryDoubao } = require('./doubao.js');
+
+function getCapabilities() {
+  return (manifest.capabilities?.provides || []).map((id) => ({
+    id,
+    version: '1.0',
+    summary: id,
+  }));
+}
+
+module.exports = {
+  manifest,
+  getCapabilities,
+  queryDoubao,
+};