shennian 0.2.87 → 0.2.89

package/dist/scripts/wechat-rpa-win-visual.mjs

@@ -1,1735 +0,0 @@
-#!/usr/bin/env node
-// @arch docs/features/wechat-rpa-channel.md
-// @test tests/wechat-rpa-win-visual.test.mjs
-
-import { spawn } from 'node:child_process'
-import crypto from 'node:crypto'
-import fs from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { recognizeWindowsScreenshot } from './wechat-rpa-windows-ocr.mjs'
-import { parseWeChatLayout } from './wechat-rpa-lab/layout/parser.mjs'
-
-const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
-const helperBridge = path.join(repoRoot, 'scripts/wechat-rpa-win.mjs')
-
-const SECTION_LABELS = new Set(['群聊', '联系人', '聊天记录', '公众号', '小程序', '朋友圈', '企业', '企业微信'])
-
-function printHelp() {
-  console.log(`Usage:
-  node scripts/wechat-rpa-win-visual.mjs --group ABC --recent-limit 5
-  node scripts/wechat-rpa-win-visual.mjs --group ABC --reply-text "我是 AI" --ocr-fixture C:\\tmp\\search-ocr.json
-  node scripts/wechat-rpa-win-visual.mjs --group ABC --file C:\\tmp\\demo.png --file C:\\tmp\\demo.mp4 --ocr-fixture C:\\tmp\\search-ocr.json
-
-Options:
-  --group <name>          Required target group/conversation name.
-  --reply-text <text>     Text to send after opening the group.
-  --file <path>           File/image/video to send. Repeatable.
-  --recent-limit <n>      Number of OCR message observations to include in summary. Default: 5.
-  --capture-dir <dir>     Directory for screenshots and debug JSON. Default: temp shennian-wechat-rpa-win-visual-*.
-  --download-attachments-dir <dir>
-                          Copy clicked inbound attachments into this directory.
-  --download-expected-token <token>
-                          Extra filename/token for cache-only download lookup. Repeatable.
-  --download-limit <n>    Maximum inbound attachments to try in one run. Defaults to 1.
-  --allow-right-click-download
-                          Allow risky right-click Copy fallback when cache-only lookup misses. Disabled by default.
-  --allow-search-open     Allow opening a group through the WeChat search panel. Disabled by default on Windows live runs.
-  --no-download-attachments
-                          Keep inbound attachments as metadata-only/pending-download.
-  --ocr-url <url>         Deprecated; accepted for compatibility but ignored.
-  --token <token>         Deprecated; accepted for compatibility but ignored.
-  --ocr-fixture <path>    Local OCR fixture JSON for deterministic selection tests/debugging.
-  --helper <path>         Override native helper exe passed through to scripts/wechat-rpa-win.mjs.
-  --open-timeout-ms <n>   Timeout waiting for title confirmation. Default: 12000.
-  --dry-run              Open/read only; do not send reply-text/files.
-
-This is the Windows commercial baseline visual RPA orchestrator: WeChat foreground + screenshot + local OCR boxes + native click/paste/press.`)
-}
-
-function takeOption(argv, name) {
-  const index = argv.indexOf(name)
-  if (index < 0) return null
-  const value = argv[index + 1]
-  if (!value || value.startsWith('--')) throw new Error(`Missing value for ${name}`)
-  argv.splice(index, 2)
-  return value
-}
-
-function takeMany(argv, name) {
-  const values = []
-  for (;;) {
-    const value = takeOption(argv, name)
-    if (value === null) break
-    values.push(value)
-  }
-  return values
-}
-
-function takeFlag(argv, name) {
-  const index = argv.indexOf(name)
-  if (index < 0) return false
-  argv.splice(index, 1)
-  return true
-}
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-function psSingleQuoted(value) {
-  return String(value).replace(/'/g, "''")
-}
-
-export function normalizeConversationName(value) {
-  const compact = String(value || '')
-    .replace(/[\s\u200b\u200c\u200d]+/g, '')
-    .replace(/夕卜/g, '外')
-    .replace(/氵则/g, '测')
-    .replace(/氵則/g, '测')
-    .replace(/讠羊/g, '群')
-    .replace(/訁羊/g, '群')
-  return compact
-    .replace(/[（(]\d+[)）]\d*$/g, '')
-    .replace(/([\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}])[0０]{1,3}$/u, '$1')
-    .trim()
-    .toLowerCase()
-}
-
-function normalizeText(value) {
-  return String(value || '').replace(/\s+/g, ' ').trim()
-}
-
-function centerOfBox(box) {
-  return {
-    x: Number(box.x || 0) + Number(box.width || 0) / 2,
-    y: Number(box.y || 0) + Number(box.height || 0) / 2,
-  }
-}
-
-function observationText(row) {
-  return normalizeText(row?.text)
-}
-
-function observationConfidence(row) {
-  const value = Number(row?.confidence)
-  return Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0.75
-}
-
-function isSection(row) {
-  const text = observationText(row)
-  return SECTION_LABELS.has(text) || /^(群聊|联系人|聊天记录|公众号|小程序|企业微信)$/.test(text)
-}
-
-export function findConversationInSearchResults(observations, targetName) {
-  const target = normalizeConversationName(targetName)
-  if (!target) throw new Error('targetName is required')
-  const rows = (Array.isArray(observations) ? observations : [])
-    .filter(row => row?.box && observationText(row))
-    .map((row, index) => ({ row, index, text: observationText(row), center: centerOfBox(row.box) }))
-    .sort((a, b) => a.center.y - b.center.y || a.center.x - b.center.x)
-
-  const sections = rows.filter(item => isSection(item.row))
-  const groupSection = sections.find(item => item.text === '群聊')
-  const nextSection = groupSection
-    ? sections.find(item => item.center.y > groupSection.center.y + 0.002)
-    : null
-
-  const exactCandidates = rows.filter(item => normalizeConversationName(item.text) === target)
-  const sectionCandidates = groupSection
-    ? exactCandidates.filter(item => {
-        if (item.center.y <= groupSection.center.y) return false
-        if (nextSection && item.center.y >= nextSection.center.y) return false
-        return true
-      })
-    : []
-
-  const fallbackCandidates = exactCandidates.filter(item => isLikelySearchResultCandidate(item.row))
-  const candidates = sectionCandidates.length > 0 ? sectionCandidates : fallbackCandidates.length > 0 ? fallbackCandidates : exactCandidates
-  if (candidates.length === 0) return null
-
-  return candidates
-    .map(item => {
-      const sectionDistance = groupSection ? Math.max(0, item.center.y - groupSection.center.y) : item.center.y
-      const horizontalPenalty = item.center.x <= 1
-        ? Math.abs(item.center.x - 0.2) * 0.5
-        : Math.abs(item.center.x - 200) * 0.005
-      const score =
-        observationConfidence(item.row) * 100
-        + (groupSection && item.center.y > groupSection.center.y ? 50 : 0)
-        - sectionDistance * 5
-        - horizontalPenalty
-      return { ...item, score }
-    })
-    .sort((a, b) => b.score - a.score)[0].row
-}
-
-function isLikelySearchResultCandidate(row) {
-  const box = row?.box || row
-  if (!box) return false
-  const x = Number(box.x || 0)
-  const y = Number(box.y || 0)
-  const width = Number(box.width || 0)
-  const height = Number(box.height || 0)
-  const normalized = Math.max(Math.abs(x), Math.abs(y), Math.abs(width), Math.abs(height)) <= 1
-  if (normalized) return x >= 0.08 && x <= 0.55 && y >= 0.12 && y <= 0.72
-  return x >= 120 && x <= 620 && y >= 120 && y <= 720
-}
-
-export function findConversationInLeftList(observations, targetName) {
-  const target = normalizeConversationName(targetName)
-  if (!target) throw new Error('targetName is required')
-  const candidates = (Array.isArray(observations) ? observations : [])
-    .filter(row => row?.box && normalizeConversationName(observationText(row)) === target && isLikelyLeftListConversation(row))
-    .map(row => ({ row, center: centerOfBox(row.box), confidence: observationConfidence(row) }))
-  if (!candidates.length) return null
-  return candidates
-    .map(item => ({
-      ...item,
-      score: item.confidence * 100 - Math.abs(item.center.x - 220) * 0.01 - item.center.y * 0.001,
-    }))
-    .sort((a, b) => b.score - a.score)[0].row
-}
-
-function isLikelyLeftListConversation(row) {
-  const box = row?.box || row
-  if (!box) return false
-  const x = Number(box.x || 0)
-  const y = Number(box.y || 0)
-  const width = Number(box.width || 0)
-  const height = Number(box.height || 0)
-  const normalized = Math.max(Math.abs(x), Math.abs(y), Math.abs(width), Math.abs(height)) <= 1
-  if (normalized) return x >= 0.10 && x <= 0.34 && y >= 0.12 && y <= 0.92
-  return x >= 120 && x <= 460 && y >= 120 && y <= 900
-}
-
-export function findTitleConfirmation(observations, targetName) {
-  const target = normalizeConversationName(targetName)
-  const rows = Array.isArray(observations) ? observations : []
-  return rows.find(row => normalizeConversationName(observationText(row)) === target && isLikelyMainTitle(row)) || null
-}
-
-export function findSendButtonObservation(observations) {
-  return (Array.isArray(observations) ? observations : [])
-    .filter(row => /^(发送|send)$/i.test(normalizedMessageText(observationText(row))) && isLikelyComposerSendButton(row))
-    .sort((left, right) => observationConfidence(right) - observationConfidence(left))[0] || null
-}
-
-export function findComposerPendingAttachmentObservation(observations) {
-  return (Array.isArray(observations) ? observations : [])
-    .filter(row => looksLikeComposerPendingAttachmentText(observationText(row)) && isLikelyComposerPendingAttachment(row))
-    .sort((left, right) => observationConfidence(right) - observationConfidence(left))[0] || null
-}
-
-export function findComposerDirtyObservation(observations) {
-  return findSendButtonObservation(observations) || findComposerPendingAttachmentObservation(observations)
-}
-
-export function isRetryableOcrError(status, body) {
-  if ([408, 429, 500, 502, 503, 504].includes(Number(status))) return true
-  return /invalid model response|timeout|temporar/i.test(String(body || ''))
-}
-
-export function pointFromObservation(capturePayload, observation, imageSize) {
-  if (!capturePayload?.bounds) throw new Error('capture payload missing bounds')
-  if (!observation?.box) throw new Error('observation missing box')
-  const bounds = capturePayload.bounds
-  const width = Number(imageSize?.width || bounds.width)
-  const height = Number(imageSize?.height || bounds.height)
-  const scaleX = Number(bounds.width) / width
-  const scaleY = Number(bounds.height) / height
-  const rawX = Number(observation.box.x)
-  const rawY = Number(observation.box.y)
-  const rawWidth = Number(observation.box.width)
-  const rawHeight = Number(observation.box.height)
-  const normalizedBox = Math.max(Math.abs(rawX), Math.abs(rawY), Math.abs(rawWidth), Math.abs(rawHeight)) <= 1
-  const cx = normalizedBox ? (rawX + rawWidth / 2) * width : rawX + rawWidth / 2
-  const cy = normalizedBox ? (rawY + rawHeight / 2) * height : rawY + rawHeight / 2
-  return {
-    x: Math.round(Number(bounds.x) + cx * scaleX),
-    y: Math.round(Number(bounds.y) + cy * scaleY),
-  }
-}
-
-export function geometryPoint(capturePayload, kind) {
-  const bounds = capturePayload?.mainWindow?.bounds || capturePayload?.bounds
-  if (!bounds) throw new Error('capture payload missing main window bounds')
-  const presets = {
-    search: [0.186, 0.087],
-    // Right-side composer: avoid the left search overlay and click inside the text area.
-    input: [0.58, 0.92],
-    fileInput: [0.58, 0.86],
-    send: [0.932, 0.945],
-  }
-  const pair = presets[kind]
-  if (!pair) throw new Error(`Unknown geometry point: ${kind}`)
-  return {
-    x: Math.round(Number(bounds.x) + Number(bounds.width) * pair[0]),
-    y: Math.round(Number(bounds.y) + Number(bounds.height) * pair[1]),
-  }
-}
-
-export function assertUsableMainWindow(capturePayload, phase = 'capture') {
-  const bounds = capturePayload?.mainWindow?.bounds || capturePayload?.bounds
-  if (!bounds) throw new Error(`${phase}: capture payload missing main window bounds`)
-  const width = Number(bounds.width)
-  const height = Number(bounds.height)
-  if (width < 760 || height < 600) {
-    throw new Error(
-      `${phase}: WeChat chat main window is not available; got ${Math.round(width)}x${Math.round(height)}. ` +
-        'The visible WeChat window looks like a login/prompt dialog, so the RPA flow was stopped.',
-    )
-  }
-  return capturePayload
-}
-
-export function readPngSize(filePath) {
-  const fd = fs.openSync(filePath, 'r')
-  try {
-    const buffer = Buffer.alloc(24)
-    fs.readSync(fd, buffer, 0, buffer.length, 0)
-    if (buffer.toString('ascii', 1, 4) !== 'PNG') throw new Error(`Not a PNG file: ${filePath}`)
-    return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) }
-  } finally {
-    fs.closeSync(fd)
-  }
-}
-
-async function runBridge(args, options) {
-  const finalArgs = [helperBridge, ...args]
-  if (options.helper) finalArgs.push('--helper', options.helper)
-  const child = spawn(process.execPath, finalArgs, {
-    cwd: repoRoot,
-    windowsHide: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
-  let stdout = ''
-  let stderr = ''
-  child.stdout.setEncoding('utf8')
-  child.stderr.setEncoding('utf8')
-  child.stdout.on('data', chunk => { stdout += chunk })
-  child.stderr.on('data', chunk => { stderr += chunk })
-  const exitCode = await new Promise((resolve, reject) => {
-    child.on('error', reject)
-    child.on('close', resolve)
-  })
-  if (stderr.trim()) process.stderr.write(stderr)
-  if (exitCode !== 0) {
-    throw new Error(`wechat-rpa-win command failed (${exitCode}): ${args.join(' ')}\n${stdout}`)
-  }
-  const trimmed = stdout.trim()
-  if (!trimmed) return null
-  try {
-    return JSON.parse(trimmed)
-  } catch (error) {
-    throw new Error(`Invalid helper JSON for ${args.join(' ')}: ${error.message}\n${stdout}`)
-  }
-}
-
-async function capture(region, options, label) {
-  const file = path.join(options.captureDir, `${String(options.step++).padStart(2, '0')}-${label || region}.png`)
-  const result = await runBridge(['capture', '--region', region, '--output', file], options)
-  if (region === 'window') assertUsableMainWindow(result?.payload, label || region)
-  return { result, payload: result?.payload, file, imageSize: readPngSize(file) }
-}
-
-async function captureWithRetry(region, options, label, retry = {}) {
-  const attempts = Number(retry.attempts || 5)
-  const delayMs = Number(retry.delayMs || 700)
-  let lastError = null
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
-    try {
-      return await capture(region, options, label)
-    } catch (error) {
-      lastError = error
-      if (!isRetryableWindowCaptureError(error) || attempt === attempts) break
-      await sleep(delayMs)
-    }
-  }
-  throw lastError
-}
-
-async function waitForStableWindow(options, label, retry = {}) {
-  const attempts = Number(retry.attempts || 6)
-  const delayMs = Number(retry.delayMs || 650)
-  let previous = null
-  let latest = null
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
-    latest = await captureWithRetry('window', options, `${label}-stability-${attempt}`, { attempts: 2, delayMs })
-    if (previous && areSameWindowBounds(previous.payload, latest.payload)) return latest
-    previous = latest
-    await sleep(delayMs)
-  }
-  return latest
-}
-
-function areSameWindowBounds(left, right) {
-  const a = left?.mainWindow?.bounds || left?.bounds
-  const b = right?.mainWindow?.bounds || right?.bounds
-  if (!a || !b) return false
-  return ['x', 'y', 'width', 'height'].every(key => Math.abs(Number(a[key]) - Number(b[key])) <= 2)
-}
-
-export function isRetryableWindowCaptureError(error) {
-  return /Cannot locate WeChat main window via (Win32|UI Automation)/i.test(String(error?.message || error || ''))
-}
-
-export function assertSearchOpenAllowed(options, targetGroup) {
-  if (options?.allowSearchOpen) return true
-  throw new Error(
-    `Target group '${targetGroup || options?.group || ''}' is not the current title or visible in the left list; ` +
-      'search-panel opening is disabled for Windows safety because it can make WeChat non-enumerable.',
-  )
-}
-
-async function click(point, options, extra = []) {
-  return runBridge(['click', '--x', String(point.x), '--y', String(point.y), ...extra], options)
-}
-
-async function rightClick(point, options, extra = []) {
-  return click(point, options, ['--right', ...extra])
-}
-
-async function readClipboard(options) {
-  const result = await runBridge(['read-clipboard'], options)
-  return result?.payload || result
-}
-
-function writeDebugArtifact(options, name, value) {
-  if (!options?.captureDir) return
-  fs.writeFileSync(path.join(options.captureDir, name), `${JSON.stringify(value, null, 2)}\n`)
-}
-
-export function prepareCaptureDir(captureDir) {
-  fs.mkdirSync(captureDir, { recursive: true })
-  for (const entry of fs.readdirSync(captureDir, { withFileTypes: true })) {
-    if (!entry.isFile()) continue
-    if (!/\.(png|json)$/i.test(entry.name)) continue
-    fs.rmSync(path.join(captureDir, entry.name), { force: true })
-  }
-}
-
-async function pasteText(text, options) {
-  return runBridge(['paste-text', '--text', text], options)
-}
-
-async function pasteFiles(files, options) {
-  return runBridge(['paste-files', ...files.flatMap(file => ['--file', file])], options)
-}
-
-async function press(keys, options) {
-  return runBridge(['press', '--keys', keys], options)
-}
-
-async function dismissMenus(options, count = 2) {
-  try {
-    return await runBridge(['dismiss-menus', '--count', String(count)], options)
-  } catch (error) {
-    if (process.platform !== 'win32') throw error
-    return dismissMenusWithPowerShell(count)
-  }
-}
-
-async function dismissMenusWithPowerShell(count = 2) {
-  const finalCount = Math.max(1, Math.min(5, Number(count) || 2))
-  const script = `
-Add-Type @"
-using System;
-using System.Runtime.InteropServices;
-public static class KeyboardDismiss {
-  [DllImport("user32.dll")]
-  public static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
-}
-
-"@
-for ($i = 0; $i -lt ${finalCount}; $i += 1) {
-  [KeyboardDismiss]::keybd_event(0x1B, 0, 0, [UIntPtr]::Zero)
-  Start-Sleep -Milliseconds 20
-  [KeyboardDismiss]::keybd_event(0x1B, 0, 0x0002, [UIntPtr]::Zero)
-  Start-Sleep -Milliseconds 90
-}
-@{ ok = $true; command = "dismiss-menus-powershell"; count = ${finalCount} } | ConvertTo-Json -Compress
-`
-  const encoded = Buffer.from(script, 'utf16le').toString('base64')
-  const child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded], {
-    windowsHide: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
-  let stdout = ''
-  let stderr = ''
-  child.stdout.setEncoding('utf8')
-  child.stderr.setEncoding('utf8')
-  child.stdout.on('data', chunk => { stdout += chunk })
-  child.stderr.on('data', chunk => { stderr += chunk })
-  const exitCode = await new Promise((resolve, reject) => {
-    child.on('error', reject)
-    child.on('close', resolve)
-  })
-  if (exitCode !== 0) {
-    throw new Error(stderr.trim() || stdout.trim() || `dismiss-menus PowerShell exited ${exitCode}`)
-  }
-  try {
-    return JSON.parse(stdout.trim())
-  } catch {
-    return { ok: true, command: 'dismiss-menus-powershell', count: finalCount, stdout: stdout.trim() }
-  }
-}
-
-async function verifyPostRunSafety(options, artifacts) {
-  try {
-    const safetyCapture = await captureWithRetry('window', options, 'post-run-safety', { attempts: 4, delayMs: 800 })
-    artifacts.push(safetyCapture.file)
-    return {
-      ok: true,
-      artifact: safetyCapture.file,
-      bounds: safetyCapture.payload?.mainWindow?.bounds || safetyCapture.payload?.bounds,
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    writeDebugArtifact(options, 'post-run-safety-error.json', {
-      ok: false,
-      message,
-    })
-    throw new Error(
-      `P0 Windows WeChat safety check failed after the visual flow: ${message}. ` +
-        'This run is not eligible for pass-rate or TODO acceptance even if the business action appeared to succeed.',
-    )
-  }
-}
-
-async function recognizeScreenshot(capture, options, purpose) {
-  const ocr = await recognizeWindowsScreenshot(capture, { ...options, isRetryableOcrError }, purpose)
-  return {
-    ...ocr,
-    layout: buildWindowsCoreLayout(capture, ocr.observations, {
-      targetGroup: options.group,
-      purpose,
-    }),
-  }
-}
-
-export function buildWindowsCoreLayout(capture, observations, options = {}) {
-  const bounds = capture?.payload?.mainWindow?.bounds || capture?.payload?.bounds || capture?.bounds || {}
-  const imageSize = capture?.imageSize || options.imageSize || {}
-  const width = Number(imageSize.width || bounds.width || 0)
-  const height = Number(imageSize.height || bounds.height || 0)
-  const windowWidth = Number(bounds.width || width || 1)
-  const windowHeight = Number(bounds.height || height || 1)
-  const screenshot = {
-    path: capture?.file || options.imagePath || '',
-    width,
-    height,
-    scale: width && windowWidth ? width / windowWidth : 1,
-    scaleX: width && windowWidth ? width / windowWidth : 1,
-    scaleY: height && windowHeight ? height / windowHeight : width && windowWidth ? width / windowWidth : 1,
-  }
-  const window = {
-    x: Number(bounds.x || 0),
-    y: Number(bounds.y || 0),
-    width: windowWidth,
-    height: windowHeight,
-    title: '微信',
-    ownerName: 'WeChat',
-  }
-  const ocr = (Array.isArray(observations) ? observations : []).map((item) => {
-    if (!item?.box || item.x != null) return item
-    return {
-      ...item,
-      x: item.box.x,
-      y: item.box.y,
-      width: item.box.width,
-      height: item.box.height,
-    }
-  })
-  return parseWeChatLayout({
-    ocr,
-    screenshot,
-    window,
-    targetGroup: options.targetGroup || options.group || '',
-  })
-}
-
-export function summarizeCoreLayout(layout) {
-  const currentTitle = layout?.currentTitle || ''
-  return {
-    currentTitle,
-    targetGroupVisible: Boolean(layout?.targetGroupVisible || currentTitle),
-    leftConversationCount: Array.isArray(layout?.leftConversationList?.items) ? layout.leftConversationList.items.length : 0,
-    searchResultCount: Array.isArray(layout?.searchResults?.sections)
-      ? layout.searchResults.sections.reduce((total, section) => total + (Array.isArray(section.items) ? section.items.length : 0), 0)
-      : 0,
-    messageCount: Array.isArray(layout?.messageArea?.messages) ? layout.messageArea.messages.length : 0,
-    attachmentCount: Array.isArray(layout?.attachmentBubbles) ? layout.attachmentBubbles.length : 0,
-    inputBox: layout?.inputBox?.rect || null,
-    messageArea: layout?.messageArea?.rect || null,
-  }
-}
-
-export function summarizeOcrEvidence(ocr = {}) {
-  const observations = Array.isArray(ocr?.observations) ? ocr.observations : []
-  return {
-    provider: ocr?.provider || '',
-    language: ocr?.language || '',
-    durationMs: Number(ocr?.durationMs || 0),
-    observationCount: observations.length,
-    lineCount: observations.filter(item => item?.providerKind === 'line').length,
-    wordCount: observations.filter(item => item?.providerKind === 'word').length,
-  }
-}
-
-export async function detectNewOutboundBubble(beforeFile, afterFile) {
-  return detectNewOutboundVisualChange(beforeFile, afterFile, {
-    kind: 'text-bubble',
-    minimumPixels: 250,
-    predicate: 'green',
-    topRatio: 0.45,
-    bottomRatio: 0.88,
-  })
-}
-
-export async function detectNewOutboundAttachmentBubble(beforeFile, afterFile) {
-  return detectNewOutboundVisualChange(beforeFile, afterFile, {
-    kind: 'attachment-bubble',
-    minimumPixels: 900,
-    predicate: 'non-background',
-    topRatio: 0.18,
-    bottomRatio: 0.84,
-  })
-}
-
-export function classifyComposerPendingAttachmentVisualMetrics(metrics = {}) {
-  const width = Number(metrics.width || 0)
-  const height = Number(metrics.height || 0)
-  const grayPixels = Number(metrics.grayPixels || 0)
-  const sampledPixels = Number(metrics.sampledPixels || 0)
-  const grayRatio = sampledPixels > 0 ? grayPixels / sampledPixels : Number(metrics.grayRatio || 0)
-  const box = metrics.box || {}
-  const boxWidth = Number(box.width || 0)
-  const boxHeight = Number(box.height || 0)
-  const boxY = Number(box.y || 0)
-  return Boolean(
-    width > 0
-    && height > 0
-    && grayPixels >= 1000
-    && grayRatio >= 0.08
-    && boxWidth >= width * 0.12
-    && boxHeight >= 18
-    && boxY >= height * 0.88
-  )
-}
-
-export async function detectComposerPendingAttachmentVisual(filePath) {
-  if (!filePath) return { ok: false, reason: 'missing image path' }
-  const script = `
-Add-Type -AssemblyName System.Drawing
-$image = [System.Drawing.Bitmap]::FromFile('${psSingleQuoted(filePath)}')
-try {
-  $left = [int]($image.Width * 0.34)
-  $right = [int]($image.Width * 0.92)
-  $top = [int]($image.Height * 0.90)
-  $bottom = [int]($image.Height * 0.995)
-  $grayPixels = 0
-  $sampledPixels = 0
-  $minX = $image.Width
-  $minY = $image.Height
-  $maxX = 0
-  $maxY = 0
-  for ($y = $top; $y -lt $bottom; $y += 2) {
-    for ($x = $left; $x -lt $right; $x += 2) {
-      $pixel = $image.GetPixel($x, $y)
-      $sampledPixels += 1
-      $spread = [Math]::Max([Math]::Abs($pixel.R - $pixel.G), [Math]::Max([Math]::Abs($pixel.G - $pixel.B), [Math]::Abs($pixel.R - $pixel.B)))
-      $isCardGray = $pixel.R -ge 228 -and $pixel.R -le 246 -and $pixel.G -ge 228 -and $pixel.G -le 246 -and $pixel.B -ge 228 -and $pixel.B -le 246 -and $spread -le 8
-      if ($isCardGray) {
-        $grayPixels += 1
-        if ($x -lt $minX) { $minX = $x }
-        if ($y -lt $minY) { $minY = $y }
-        if ($x -gt $maxX) { $maxX = $x }
-        if ($y -gt $maxY) { $maxY = $y }
-      }
-    }
-  }
-  $grayRatio = 0
-  if ($sampledPixels -gt 0) { $grayRatio = $grayPixels / $sampledPixels }
-  @{
-    kind = "composer-pending-attachment-visual"
-    width = $image.Width
-    height = $image.Height
-    sampledPixels = $sampledPixels
-    grayPixels = $grayPixels
-    grayRatio = $grayRatio
-    scan = @{ left = $left; right = $right; top = $top; bottom = $bottom; step = 2 }
-    box = @{ x = $minX; y = $minY; width = [Math]::Max(0, $maxX - $minX); height = [Math]::Max(0, $maxY - $minY) }
-  } | ConvertTo-Json -Depth 4 -Compress
-} finally {
-  $image.Dispose()
-}
-`
-  const encoded = Buffer.from(script, 'utf16le').toString('base64')
-  const child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded], {
-    windowsHide: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
-  let stdout = ''
-  let stderr = ''
-  child.stdout.setEncoding('utf8')
-  child.stderr.setEncoding('utf8')
-  child.stdout.on('data', chunk => { stdout += chunk })
-  child.stderr.on('data', chunk => { stderr += chunk })
-  const exitCode = await new Promise((resolve, reject) => {
-    child.on('error', reject)
-    child.on('close', resolve)
-  })
-  if (exitCode !== 0) return { ok: false, reason: stderr.trim() || `powershell exited ${exitCode}` }
-  try {
-    const metrics = JSON.parse(stdout.trim())
-    return {
-      ...metrics,
-      ok: classifyComposerPendingAttachmentVisualMetrics(metrics),
-    }
-  } catch {
-    return { ok: false, reason: stdout.trim() || 'invalid composer visual detector JSON' }
-  }
-}
-
-export function attachmentVisualBeforeFile(opened = {}, pendingCapture = {}) {
-  return pendingCapture?.file || opened?.file || null
-}
-
-async function detectNewOutboundVisualChange(beforeFile, afterFile, detector) {
-  if (!beforeFile || !afterFile) return { ok: false, reason: 'missing image path', kind: detector.kind }
-  const script = `
-Add-Type -AssemblyName System.Drawing
-$before = [System.Drawing.Bitmap]::FromFile('${psSingleQuoted(beforeFile)}')
-$after = [System.Drawing.Bitmap]::FromFile('${psSingleQuoted(afterFile)}')
-try {
-  if ($before.Width -ne $after.Width -or $before.Height -ne $after.Height) {
-    @{ ok = $false; reason = "image size mismatch"; changedGreenPixels = 0 } | ConvertTo-Json -Compress
-    exit 0
-  }
-  $left = [int]($after.Width * 0.52)
-  $right = [int]($after.Width * 0.96)
-  $top = [int]($after.Height * ${Number(detector.topRatio)})
-  $bottom = [int]($after.Height * ${Number(detector.bottomRatio)})
-  $changedPixels = 0
-  $minX = $after.Width
-  $minY = $after.Height
-  $maxX = 0
-  $maxY = 0
-  for ($y = $top; $y -lt $bottom; $y += 2) {
-    for ($x = $left; $x -lt $right; $x += 2) {
-      $a = $after.GetPixel($x, $y)
-      $b = $before.GetPixel($x, $y)
-      $isGreen = $a.G -ge 175 -and $a.R -ge 80 -and $a.R -le 190 -and $a.B -ge 50 -and $a.B -le 180 -and ($a.G - $a.R) -ge 25 -and ($a.G - $a.B) -ge 45
-      $isNonBackground = -not ($a.R -ge 245 -and $a.G -ge 245 -and $a.B -ge 245) -and -not ($a.R -ge 235 -and $a.G -ge 235 -and $a.B -ge 235 -and [Math]::Abs($a.R - $a.G) -le 5 -and [Math]::Abs($a.G - $a.B) -le 5)
-      $changed = ([Math]::Abs($a.R - $b.R) + [Math]::Abs($a.G - $b.G) + [Math]::Abs($a.B - $b.B)) -ge 45
-      $wanted = ${detector.predicate === 'green' ? '$isGreen' : '$isNonBackground'}
-      if ($wanted -and $changed) {
-        $changedPixels += 1
-        if ($x -lt $minX) { $minX = $x }
-        if ($y -lt $minY) { $minY = $y }
-        if ($x -gt $maxX) { $maxX = $x }
-        if ($y -gt $maxY) { $maxY = $y }
-      }
-    }
-  }
-  @{
-    ok = $changedPixels -ge ${Number(detector.minimumPixels)}
-    kind = "${psSingleQuoted(detector.kind)}"
-    changedPixels = $changedPixels
-    sampledStep = 2
-    box = @{ x = $minX; y = $minY; width = [Math]::Max(0, $maxX - $minX); height = [Math]::Max(0, $maxY - $minY) }
-  } | ConvertTo-Json -Depth 4 -Compress
-} finally {
-  $before.Dispose()
-  $after.Dispose()
-}
-`
-  const encoded = Buffer.from(script, 'utf16le').toString('base64')
-  const child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded], {
-    windowsHide: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
-  let stdout = ''
-  let stderr = ''
-  child.stdout.setEncoding('utf8')
-  child.stderr.setEncoding('utf8')
-  child.stdout.on('data', chunk => { stdout += chunk })
-  child.stderr.on('data', chunk => { stderr += chunk })
-  const exitCode = await new Promise((resolve, reject) => {
-    child.on('error', reject)
-    child.on('close', resolve)
-  })
-  if (exitCode !== 0) return { ok: false, reason: stderr.trim() || `powershell exited ${exitCode}` }
-  try {
-    return JSON.parse(stdout.trim())
-  } catch {
-    return { ok: false, reason: stdout.trim() || 'invalid bubble detector JSON' }
-  }
-}
-
-export function summarizeObservations(observations, limit) {
-  return (Array.isArray(observations) ? observations : [])
-    .filter(row => observationText(row))
-    .filter(isUsefulSummaryObservation)
-    .sort((a, b) => observationBottom(a) - observationBottom(b))
-    .slice(-limit)
-    .map(row => ({
-      text: observationText(row),
-      role: row.role || 'unknown',
-      confidence: observationConfidence(row),
-      ...(row.attachment ? { attachment: row.attachment } : {}),
-      box: row.box,
-    }))
-}
-
-function observationBottom(row) {
-  const box = row?.box || row
-  return Number(box?.y || 0) + Number(box?.height || 0)
-}
-
-function isUsefulSummaryObservation(row) {
-  const text = observationText(row)
-  const compact = normalizedMessageText(text)
-  if (!compact) return false
-  if (/^[0-9:：.\-]+$/.test(compact)) return false
-  if (/^[0-9]{1,2}[a-z\u0400-\u04ff]{1,3}[0-9]{1,2}$/i.test(compact)) return false
-  if (/^[0-9].*[0-9]$/.test(compact) && compact.length <= 8) return false
-  if (compact.replace(/^[0０]+/, '') === normalizedMessageText('微信电脑版')) return false
-  if (compact === '0') return false
-  return compact.length >= 2 || Boolean(row?.attachment)
-}
-
-function normalizedMessageText(value) {
-  return String(value || '').replace(/\s+/g, '').toLowerCase()
-}
-
-export function observationsContainText(observations, text) {
-  const target = normalizedMessageText(text)
-  if (!target) return true
-  return (Array.isArray(observations) ? observations : []).some(row => {
-    const content = normalizedMessageText(observationText(row))
-    return isStrongTextMatch(content, target)
-  })
-}
-
-export function findSentTextConfirmation(observations, text) {
-  const target = normalizedMessageText(text)
-  if (!target) return null
-  return (Array.isArray(observations) ? observations : []).find(row => {
-    const content = normalizedMessageText(observationText(row))
-    return isStrongTextMatch(content, target) && isLikelyOutboundMessageText(row)
-  }) || null
-}
-
-async function confirmSentText(confirmOcr, text, beforeCapture, afterCapture) {
-  const ocrHit = findSentTextConfirmation(confirmOcr.observations, text)
-  if (ocrHit) return { method: 'ocr-outbound-text', observation: ocrHit }
-
-  const visual = await detectNewOutboundBubble(beforeCapture?.file, afterCapture?.file)
-  if (visual?.ok) {
-    return {
-      method: 'visual-new-outbound-bubble',
-      observation: {
-        text,
-        role: 'outbound-visual',
-        confidence: 0,
-        box: visual.box,
-        visual,
-      },
-    }
-  }
-
-  return { method: 'none', visual }
-}
-
-async function assertComposerEmptyBeforeSend(options, artifacts) {
-  const composerCapture = await capture('window', options, 'composer-before-send')
-  artifacts.push(composerCapture.file)
-  const composerOcr = await recognizeScreenshot(composerCapture, options, 'composer-before-send')
-  const dirtyObservation = findComposerDirtyObservation(composerOcr.observations)
-  const dirtyVisual = dirtyObservation ? null : await detectComposerPendingAttachmentVisual(composerCapture.file)
-  if (dirtyObservation || dirtyVisual?.ok) {
-    writeJsonArtifact(options, 'composer-before-send-ocr.json', {
-      ocrEvidence: summarizeOcrEvidence(composerOcr),
-      dirtyObservation,
-      dirtyVisual,
-      sample: summarizeObservations(composerOcr.observations, 20),
-    })
-    throw new Error(
-      'WeChat composer is not empty before send; pending text or attachments are already staged. ' +
-      `Refusing to paste/send new content. See ${composerCapture.file}`,
-    )
-  }
-  return { capture: composerCapture, ocr: composerOcr }
-}
-
-function isLikelyOutboundMessageText(row) {
-  const box = row?.box || row
-  if (!box) return false
-  const x = Number(box.x || 0)
-  const y = Number(box.y || 0)
-  const width = Number(box.width || 0)
-  const height = Number(box.height || 0)
-  const normalized = Math.max(Math.abs(x), Math.abs(y), Math.abs(width), Math.abs(height)) <= 1
-  const centerX = x + width / 2
-  const centerY = y + height / 2
-  if (normalized) return centerX >= 0.52 && centerY >= 0.22 && centerY <= 0.88
-  return centerX >= 700 && centerY >= 180 && centerY <= 900
-}
-
-function isLikelyComposerSendButton(row) {
-  const box = row?.box || row
-  if (!box) return false
-  const x = Number(box.x || 0)
-  const y = Number(box.y || 0)
-  const width = Number(box.width || 0)
-  const height = Number(box.height || 0)
-  const normalized = Math.max(Math.abs(x), Math.abs(y), Math.abs(width), Math.abs(height)) <= 1
-  const centerX = x + width / 2
-  const centerY = y + height / 2
-  if (normalized) return centerX >= 0.78 && centerY >= 0.82
-  return centerX >= 900 && centerY >= 720
-}
-
-function normalizedObservationCenter(row) {
-  const box = row?.box || row
-  if (!box) return null
-  const x = Number(box.x || 0)
-  const y = Number(box.y || 0)
-  const width = Number(box.width || 0)
-  const height = Number(box.height || 0)
-  const centerX = x + width / 2
-  const centerY = y + height / 2
-  const normalized = Math.max(Math.abs(x), Math.abs(y), Math.abs(width), Math.abs(height)) <= 1
-  if (normalized) return { x: centerX, y: centerY }
-  const imageWidth = Number(row?.imageWidth || box.imageWidth || 0)
-  const imageHeight = Number(row?.imageHeight || box.imageHeight || 0)
-  if (imageWidth > 0 && imageHeight > 0) return { x: centerX / imageWidth, y: centerY / imageHeight }
-  return { x: centerX / 1800, y: centerY / 1100 }
-}
-
-function looksLikeComposerPendingAttachmentText(value) {
-  const text = normalizedMessageText(value)
-    .replace(/[．。]/g, '.')
-    .replace(/[｜|]/g, 'i')
-  return /\.(txt|csv|pdf|docx?|xlsx?|pptx?|zip|rar|7z|png|jpe?g|gif|webp|bmp|mp4|mov|avi|mkv|webm)$/i.test(text) ||
-    /\.(txt|csv|pdf|docx?|xlsx?|pptx?|zip|rar|7z|png|jpe?g|gif|webp|bmp|mp4|mov|avi|mkv|webm)\b/i.test(text)
-}
-
-function isLikelyComposerPendingAttachment(row) {
-  const center = normalizedObservationCenter(row)
-  if (!center) return false
-  return center.x >= 0.26 && center.x <= 0.86 && center.y >= 0.78
-}
-
-function isLikelyMainTitle(row) {
-  const box = row?.box || row
-  if (!box) return false
-  const x = Number(box.x || 0)
-  const y = Number(box.y || 0)
-  const width = Number(box.width || 0)
-  const height = Number(box.height || 0)
-  const normalized = Math.max(Math.abs(x), Math.abs(y), Math.abs(width), Math.abs(height)) <= 1
-  if (normalized) return x >= 0.32 && y <= 0.18
-  return x >= 360 && y <= 160
-}
-
-function isStrongTextMatch(content, target) {
-  if (!content || !target) return false
-  if (content.includes(target)) return true
-  const minimumReverseLength = Math.min(8, Math.max(4, Math.ceil(target.length * 0.5)))
-  return content.length >= minimumReverseLength && target.includes(content)
-}
-
-function basenameForAnyPlatform(file) {
-  const value = String(file || '')
-  return value.includes('\\') ? path.win32.basename(value) : path.basename(value)
-}
-
-function safeFileName(name) {
-  return path.basename(name || 'attachment')
-    .normalize('NFKC')
-    .replace(/[<>:"/\\|?*\x00-\x1F]/g, '_')
-    .replace(/\s+/g, ' ')
-    .replace(/^[ ._]+|[ ._]+$/g, '')
-    || 'attachment'
-}
-
-function uniqueInboundPath(dir, name, hash) {
-  const safe = safeFileName(name || 'attachment')
-  const ext = path.extname(safe)
-  const stem = ext ? safe.slice(0, -ext.length) : safe
-  const candidate = path.join(dir, safe)
-  if (!fs.existsSync(candidate)) return candidate
-  return path.join(dir, `${stem}-${hash.slice(0, 12)}${ext}`)
-}
-
-function mimeTypeFromExt(ext) {
-  const value = String(ext || '').toLowerCase()
-  if (['.jpg', '.jpeg'].includes(value)) return 'image/jpeg'
-  if (value === '.png') return 'image/png'
-  if (value === '.gif') return 'image/gif'
-  if (value === '.webp') return 'image/webp'
-  if (value === '.mp4') return 'video/mp4'
-  if (value === '.mov') return 'video/quicktime'
-  if (value === '.pdf') return 'application/pdf'
-  if (value === '.txt') return 'text/plain'
-  if (value === '.docx') return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
-  if (value === '.xlsx') return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-  if (value === '.pptx') return 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
-  if (value === '.zip') return 'application/zip'
-  return 'application/octet-stream'
-}
-
-function attachmentFromText(text) {
-  const normalized = normalizeFileCardText(text)
-  const match = normalized.match(/[a-z0-9][a-z0-9._-]{2,}\.(txt|pdf|docx?|xlsx?|pptx?|zip|rar|7z|png|jpe?g|gif|webp|mp4|mov|avi|mkv|webm)\b/i)
-  if (!match) return null
-  const name = safeFileName(match[0])
-  const ext = path.extname(name).toLowerCase()
-  return {
-    type: attachmentTypeFromExt(ext),
-    name,
-    mimeType: mimeTypeFromExt(ext),
-    availability: 'remote',
-  }
-}
-
-function normalizeFileCardText(text) {
-  return String(text || '')
-    .normalize('NFKC')
-    .replace(/w[l1i]n/gi, 'win')
-    .replace(/[一－—–]/g, '-')
-    .replace(/[．。·]/g, '.')
-    .replace(/\s+/g, '')
-}
-
-function attachmentTypeFromExt(ext) {
-  if (IMAGE_EXTENSIONS.has(String(ext || '').toLowerCase())) return 'image'
-  if (VIDEO_EXTENSIONS.has(String(ext || '').toLowerCase())) return 'video'
-  return 'file'
-}
-
-function postPasteDelayMs(file) {
-  const type = classifyOutboundFile(file).type
-  if (type === 'image') return 8_000
-  if (type === 'video') return 15_000
-  return 2_000
-}
-
-const IMAGE_EXTENSIONS = new Set(['.apng', '.avif', '.bmp', '.gif', '.heic', '.heif', '.jpeg', '.jpg', '.png', '.tif', '.tiff', '.webp'])
-const VIDEO_EXTENSIONS = new Set(['.3g2', '.3gp', '.avi', '.m4v', '.mkv', '.mov', '.mp4', '.mpeg', '.mpg', '.webm', '.wmv'])
-
-export function classifyOutboundFile(file) {
-  const name = basenameForAnyPlatform(file)
-  const ext = path.extname(name).toLowerCase()
-  const type = IMAGE_EXTENSIONS.has(ext) ? 'image' : VIDEO_EXTENSIONS.has(ext) ? 'video' : 'file'
-  return {
-    type,
-    name,
-    localPath: file,
-    availability: 'edge-local',
-  }
-}
-
-export function copyInboundAttachment(source, targetDir, attachment) {
-  const buffer = fs.readFileSync(source.path)
-  const hash = crypto.createHash('sha256').update(buffer).digest('hex')
-  const sourceName = path.basename(source.path)
-  const preferredName = attachment?.name && /\.[\p{L}\p{N}]+$/u.test(attachment.name) ? attachment.name : sourceName
-  const filePath = uniqueInboundPath(targetDir, preferredName, hash)
-  fs.mkdirSync(targetDir, { recursive: true })
-  if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, buffer)
-  const ext = path.extname(filePath).toLowerCase()
-  return {
-    type: attachment?.type || attachmentTypeFromExt(ext),
-    name: path.basename(filePath),
-    mimeType: attachment?.mimeType || mimeTypeFromExt(ext),
-    size: buffer.byteLength,
-    localPath: filePath,
-    hash,
-    availability: 'edge-local',
-  }
-}
-
-export function summarizeAttachmentObservations(observations, limit) {
-  return (Array.isArray(observations) ? observations : [])
-    .filter(row => row?.box && observationText(row))
-    .map(row => {
-      const attachment = row.attachment || attachmentFromText(observationText(row)) || attachmentFromSizeRow(row)
-      if (!attachment) return null
-      return {
-        text: observationText(row) || attachment.name,
-        role: row.role || 'unknown',
-        confidence: observationConfidence(row),
-        box: row.box,
-        attachment,
-      }
-    })
-    .filter(Boolean)
-    .sort((a, b) => observationBottom(a) - observationBottom(b))
-    .slice(-limit)
-}
-
-function attachmentFromSizeRow(row) {
-  const text = normalizedMessageText(observationText(row)).replace(/,/g, '')
-  const box = row?.box || row
-  const x = Number(box?.x || 0)
-  if (!/^\d+(?:\.\d+)?(?:b|kb|mb|gb)$/.test(text)) return null
-  if (x < 260) return null
-  return {
-    type: 'file',
-    name: 'wechat-attachment',
-    mimeType: 'application/octet-stream',
-    availability: 'remote',
-  }
-}
-
-function mergeRecentMessagesWithAttachments(recentMessages, attachmentMessages, limit) {
-  const merged = [...recentMessages]
-  for (const message of attachmentMessages) {
-    const existingIndex = merged.findIndex(item => item.attachment?.name === message.attachment?.name || (
-      item.box && message.box && Math.abs(observationBottom(item) - observationBottom(message)) < 8
-    ))
-    if (existingIndex >= 0) {
-      if (!merged[existingIndex].attachment && message.attachment) merged[existingIndex] = { ...merged[existingIndex], attachment: message.attachment }
-    } else {
-      merged.push(message)
-    }
-  }
-  return merged
-    .sort((a, b) => observationBottom(a) - observationBottom(b))
-    .slice(-limit)
-}
-
-function clipboardSourceFile(payload) {
-  const files = Array.isArray(payload?.files) ? payload.files : Array.isArray(payload?.Files) ? payload.Files : []
-  for (const file of files) {
-    const candidate = String(file || '').trim()
-    if (candidate && fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
-      return { path: candidate, size: fs.statSync(candidate).size, mtimeMs: fs.statSync(candidate).mtimeMs }
-    }
-  }
-
-  const text = String(payload?.text || payload?.Text || '')
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim().replace(/^["']|["']$/g, '')
-    const candidate = line.startsWith('file:///') ? decodeURIComponent(line.replace(/^file:\/\/\//i, '')) : line
-    if (candidate && fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
-      return { path: candidate, size: fs.statSync(candidate).size, mtimeMs: fs.statSync(candidate).mtimeMs }
-    }
-  }
-
-  return null
-}
-
-function defaultWeChatCacheRoots() {
-  const roots = []
-  const home = process.env.USERPROFILE || process.env.HOME
-  if (home) {
-    roots.push(path.join(home, 'Documents', 'xwechat_files'))
-    roots.push(path.join(home, 'Documents', 'WeChat Files'))
-  }
-  return roots
-}
-
-function extensionForAttachment(attachment = {}, options = {}) {
-  const name = String(attachment.name || '')
-  const ext = path.extname(name).toLowerCase()
-  if (ext) return ext
-  for (const token of Array.isArray(options.downloadExpectedTokens) ? options.downloadExpectedTokens : []) {
-    const tokenExt = path.extname(String(token || '')).toLowerCase()
-    if (tokenExt) return tokenExt
-  }
-  const mime = String(attachment.mimeType || '').toLowerCase()
-  if (mime === 'image/png') return '.png'
-  if (mime === 'image/jpeg') return '.jpg'
-  if (mime === 'image/gif') return '.gif'
-  if (mime === 'application/pdf') return '.pdf'
-  if (mime.includes('mp4')) return '.mp4'
-  return ''
-}
-
-function cacheLookupTokens(message = {}, attachment = {}, options = {}) {
-  const values = [
-    message.text,
-    attachment.name,
-    ...(Array.isArray(options.downloadExpectedTokens) ? options.downloadExpectedTokens : []),
-  ].map(value => normalizedFileNameToken(value)).filter(Boolean)
-  const tokens = new Set()
-  for (const value of values) {
-    for (const token of value.split(/[^a-z0-9]+/i)) {
-      if (token.length >= 4 && !/^(file|image|video|pdf|png|jpg|jpeg|mp4)$/i.test(token)) {
-        tokens.add(token.toLowerCase())
-      }
-    }
-    if (value.length >= 8) tokens.add(value.toLowerCase())
-  }
-  return [...tokens]
-}
-
-export function expectedDownloadTokenMessages(options = {}) {
-  return (Array.isArray(options.downloadExpectedTokens) ? options.downloadExpectedTokens : [])
-    .map((token) => {
-      const name = safeFileName(basenameForAnyPlatform(token))
-      const ext = path.extname(name).toLowerCase()
-      if (!ext) return null
-      return {
-        text: name,
-        role: 'expected-download-token',
-        confidence: 0,
-        attachment: {
-          type: attachmentTypeFromExt(ext),
-          name,
-          mimeType: mimeTypeFromExt(ext),
-          availability: 'remote',
-        },
-      }
-    })
-    .filter(Boolean)
-}
-
-function candidateCacheFiles(roots, options = {}) {
-  const maxFiles = Number(options.maxCacheFiles || 5000)
-  const minMtimeMs = Date.now() - Number(options.maxCacheAgeMs || 14 * 24 * 60 * 60 * 1000)
-  const files = []
-  const stack = roots.filter(Boolean).map(root => path.resolve(root))
-  const seen = new Set()
-  while (stack.length && files.length < maxFiles) {
-    const current = stack.pop()
-    if (!current || seen.has(current)) continue
-    seen.add(current)
-    let entries = []
-    try {
-      entries = fs.readdirSync(current, { withFileTypes: true })
-    } catch {
-      continue
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(current, entry.name)
-      if (entry.isDirectory()) {
-        if (/^(cache|temp|rwtemp|filestorage|msgattach|image|video|file|[0-9-]+)$/i.test(entry.name) || current.toLowerCase().includes('xwechat_files')) {
-          stack.push(fullPath)
-        }
-        continue
-      }
-      if (!entry.isFile()) continue
-      let stat
-      try {
-        stat = fs.statSync(fullPath)
-      } catch {
-        continue
-      }
-      if (stat.mtimeMs < minMtimeMs || stat.size <= 0) continue
-      files.push({ path: fullPath, size: stat.size, mtimeMs: stat.mtimeMs, name: entry.name })
-      if (files.length >= maxFiles) break
-    }
-  }
-  return files.sort((a, b) => b.mtimeMs - a.mtimeMs)
-}
-
-export function findCachedInboundAttachment(message = {}, attachment = {}, options = {}) {
-  const ext = extensionForAttachment(attachment, options)
-  const tokens = cacheLookupTokens(message, attachment, options)
-  const roots = options.wechatCacheRoots || defaultWeChatCacheRoots()
-  if (!ext || tokens.length === 0 || roots.length === 0) return null
-  const candidates = candidateCacheFiles(roots, options)
-    .filter(file => path.extname(file.name).toLowerCase() === ext)
-    .map(file => {
-      const normalizedName = normalizedFileNameToken(file.name)
-      const score = tokens.reduce((sum, token) => sum + (normalizedName.includes(token) ? Math.min(20, token.length) : 0), 0)
-      return { ...file, score }
-    })
-    .filter(file => file.score > 0)
-    .sort((a, b) => b.score - a.score || b.mtimeMs - a.mtimeMs)
-  const best = candidates[0]
-  return best ? { path: best.path, size: best.size, mtimeMs: best.mtimeMs } : null
-}
-
-export function findCopyMenuItem(observations) {
-  const rows = (Array.isArray(observations) ? observations : [])
-    .filter(row => row?.box && observationText(row))
-    .map(row => ({ row, text: normalizeText(observationText(row)).toLowerCase() }))
-  return rows.find(({ text }) => /^(复制|拷贝|copy)$/i.test(text))?.row
-    || rows.find(({ text }) => /复制|拷贝|\bcopy\b/i.test(text))?.row
-    || null
-}
-
-function attachmentRightClickPoint(capturePayload, message, imageSize) {
-  const point = pointFromObservation(capturePayload, message, imageSize)
-  const box = message?.box || {}
-  const text = normalizedMessageText(observationText(message)).replace(/,/g, '')
-  const isSizeOnly = /^\d+(?:\.\d+)?(?:b|kb|mb|gb)$/.test(text)
-  if (!isSizeOnly) return point
-
-  const scale = imageSize?.width && Number(box.x || 0) <= 1 && Number(box.width || 0) <= 1 ? imageSize.width : 1
-  const width = Number(box.width || 0) * scale
-  return {
-    x: Math.round(point.x + Math.max(48, Math.min(140, width + 72))),
-    y: Math.round(point.y - 18),
-  }
-}
-
-async function localizeInboundAttachments(recentMessages, messageCapture, options) {
-  if (options.downloadAttachments === false || !options.downloadAttachmentsDir) {
-    return { recentMessages, downloads: [] }
-  }
-  const targetDir = path.resolve(options.downloadAttachmentsDir)
-  fs.mkdirSync(targetDir, { recursive: true })
-  const maxDownloads = downloadAttachmentLimit(options)
-  const downloads = []
-  const updated = []
-  const messages = [...recentMessages]
-  for (const expected of expectedDownloadTokenMessages(options)) {
-    const exists = messages.some(message => message?.attachment?.name === expected.attachment.name)
-    if (!exists) messages.push(expected)
-  }
-  for (const message of messages) {
-    if (downloads.length >= maxDownloads) {
-      updated.push(message)
-      continue
-    }
-    const attachment = message.attachment
-    if (!attachment || attachment.localPath || attachment.url) {
-      updated.push(message)
-      continue
-    }
-    const cached = findCachedInboundAttachment(message, attachment, options)
-    if (cached) {
-      const localized = copyInboundAttachment(cached, targetDir, attachment)
-      updated.push({ ...message, text: message.text || localized.name, attachment: localized })
-      downloads.push({ text: message.text, ok: true, strategy: 'wechat-cache-scan', sourcePath: cached.path, localPath: localized.localPath, size: localized.size })
-      continue
-    }
-    if (!options.allowRightClickDownload) {
-      const pending = {
-        ...message,
-        attachment: {
-          ...attachment,
-          availability: 'pending-download',
-          providerError: 'No matching local WeChat cache file found; right-click download fallback is disabled on Windows.',
-        },
-      }
-      updated.push(pending)
-      downloads.push({ text: message.text, ok: false, strategy: 'wechat-cache-scan', providerError: pending.attachment.providerError })
-      continue
-    }
-    if (!message.box) {
-      const pending = {
-        ...message,
-        attachment: {
-          ...attachment,
-          availability: 'pending-download',
-          providerError: 'Right-click download fallback requires an OCR box, but cache-only lookup did not find a local file.',
-        },
-      }
-      updated.push(pending)
-      downloads.push({ text: message.text, ok: false, strategy: 'right-click-copy', providerError: pending.attachment.providerError })
-      continue
-    }
-    const targetPoint = attachmentRightClickPoint(messageCapture.payload, message, messageCapture.imageSize)
-    writeDebugArtifact(options, `download-attachment-${downloads.length + 1}-target.json`, {
-      text: message.text,
-      box: message.box,
-      point: targetPoint,
-      strategy: 'right-click-copy',
-    })
-    await rightClick(targetPoint, options, ['--no-raise'])
-    await sleep(350)
-
-    let copied = null
-    let providerError = ''
-    try {
-      const menuCapture = await capture('window', options, `context-menu-${downloads.length + 1}`)
-      const menuOcr = await recognizeScreenshot(menuCapture, options, 'context-menu')
-      writeDebugArtifact(options, `download-attachment-${downloads.length + 1}-menu.json`, menuOcr.observations)
-      const copyItem = findCopyMenuItem(menuOcr.observations)
-      if (!copyItem) {
-        providerError = 'Right-click attachment menu did not expose a Copy item'
-      } else {
-        await click(pointFromObservation(menuCapture.payload, copyItem, menuCapture.imageSize), options, ['--no-raise'])
-        await sleep(350)
-        const clipboard = await readClipboard(options)
-        writeDebugArtifact(options, `download-attachment-${downloads.length + 1}-clipboard.json`, clipboard)
-        copied = clipboardSourceFile(clipboard)
-        if (!copied) providerError = 'Right-click Copy did not put a local file path on the clipboard'
-      }
-    } finally {
-      await dismissMenus(options, 2).catch(() => {})
-      await press('{ESC}', options).catch(() => {})
-    }
-
-    if (!copied) {
-      const pending = {
-        ...message,
-        attachment: {
-          ...attachment,
-          availability: 'pending-download',
-          providerError,
-        },
-      }
-      updated.push(pending)
-      downloads.push({ text: message.text, ok: false, providerError: pending.attachment.providerError })
-      continue
-    }
-    const localized = copyInboundAttachment(copied, targetDir, attachment)
-    updated.push({ ...message, text: message.text || localized.name, attachment: localized })
-    downloads.push({ text: message.text, ok: true, sourcePath: copied.path, localPath: localized.localPath, size: localized.size })
-  }
-  return { recentMessages: updated, downloads }
-}
-
-export function downloadAttachmentLimit(options = {}) {
-  const value = Number(options.downloadLimit ?? 1)
-  if (!Number.isFinite(value) || value < 1) return 1
-  // Windows WeChat can lose its enumerable main window after repeated
-  // right-click attachment menus. Keep live runs to one attachment until this
-  // path has a separate stability gate.
-  return Math.min(1, Math.floor(value))
-}
-
-export function missingConfirmedFiles(observations, files) {
-  const rows = Array.isArray(observations) ? observations : []
-  const combinedText = normalizedMessageText(rows.map(row => observationText(row)).join(''))
-  const combinedFileToken = normalizedFileNameToken(rows.map(row => observationText(row)).join(''))
-  return (files || []).filter(file => {
-    const basename = basenameForAnyPlatform(file)
-    const normalizedBasename = normalizedMessageText(basename)
-    const normalizedFileToken = normalizedFileNameToken(basename)
-    if (combinedText.includes(normalizedBasename)) return false
-    if (normalizedFileToken && combinedFileToken.includes(normalizedFileToken)) return false
-    return !rows.some(row => {
-      const text = normalizedMessageText(observationText(row))
-      const attachmentName = normalizedMessageText(row?.attachment?.filename || row?.attachment?.name)
-      const fileText = normalizedFileNameToken(observationText(row))
-      const fileAttachmentName = normalizedFileNameToken(row?.attachment?.filename || row?.attachment?.name)
-      return text.includes(normalizedBasename)
-        || attachmentName.includes(normalizedBasename)
-        || (normalizedFileToken && fileText.includes(normalizedFileToken))
-        || (normalizedFileToken && fileAttachmentName.includes(normalizedFileToken))
-    })
-  })
-}
-
-function normalizedFileNameToken(value) {
-  return String(value || '')
-    .normalize('NFKC')
-    .toLowerCase()
-    .replace(/w[l1i]n/g, 'win')
-    .replace(/[\s._\-—–一．。·,，:：;；/\\|[\]()（）{}<>《》"'“”‘’]+/g, '')
-    .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '')
-}
-
-async function openConversationBySearch(options, artifacts) {
-  const initial = await capture('window', options, 'window-before-search')
-  artifacts.push(initial.file)
-  try {
-    const initialTitleOcr = await recognizeScreenshot(initial, options, 'title-confirmation')
-    if (findTitleConfirmation(initialTitleOcr.observations, options.group)) {
-      initial.openEvidence = {
-        strategy: 'current-title',
-        searchUsed: false,
-        leftListUsed: false,
-        titleConfirmed: true,
-      }
-      return initial
-    }
-  } catch (error) {
-    process.stderr.write(`Initial title OCR was skipped: ${error instanceof Error ? error.message : String(error)}\n`)
-  }
-  const initialOcr = await recognizeScreenshot(initial, options, 'left-list')
-  const leftListTarget = findConversationInLeftList(initialOcr.observations, options.group)
-  if (leftListTarget) {
-    const targetPoint = pointFromObservation(initial.payload, leftListTarget, initial.imageSize)
-    writeDebugArtifact(options, 'open-target-left-list.json', {
-      group: options.group,
-      text: observationText(leftListTarget),
-      box: leftListTarget.box,
-      point: targetPoint,
-    })
-    await click(targetPoint, options, ['--no-raise'])
-    await sleep(650)
-    const opened = await waitForStableWindow(options, 'opened-from-left-list', { attempts: 6, delayMs: 800 })
-    artifacts.push(opened.file)
-    const titleOcr = await recognizeScreenshot(opened, options, 'title-confirmation')
-    const titleConfirmed = Boolean(findTitleConfirmation(titleOcr.observations, options.group))
-    if (!titleConfirmed) {
-      if (!options.allowWeakTitle) throw new Error(`Opened left-list conversation title was not confirmed as '${options.group}'. See ${opened.file}`)
-    }
-    opened.openEvidence = {
-      strategy: 'left-list',
-      searchUsed: false,
-      leftListUsed: true,
-      titleConfirmed,
-      targetText: observationText(leftListTarget),
-    }
-    return opened
-  }
-
-  assertSearchOpenAllowed(options, options.group)
-
-  await click(geometryPoint(initial.payload, 'search'), options)
-  await sleep(180)
-  await press('^a', options)
-  await pasteText(options.group, options)
-  await sleep(650)
-
-  const searchCapture = await capture('window', options, 'search-results')
-  artifacts.push(searchCapture.file)
-  const searchOcr = await recognizeScreenshot(searchCapture, options, 'search-results')
-  const target = findConversationInSearchResults(searchOcr.observations, options.group)
-  if (!target) {
-    throw new Error(`Could not find target group '${options.group}' under search result section '群聊'. See ${searchCapture.file}`)
-  }
-  const targetPoint = pointFromObservation(searchCapture.payload, target, searchCapture.imageSize)
-  writeDebugArtifact(options, 'open-target-search.json', {
-    group: options.group,
-    text: observationText(target),
-    box: target.box,
-    point: targetPoint,
-  })
-  await click(targetPoint, options, ['--no-raise'])
-  await sleep(350)
-  // WeChat 4.x can keep the transient search result panel open after clicking a result.
-  // Close it explicitly so later input/send geometry always targets the conversation composer.
-  await press('{ESC}', options)
-  await sleep(500)
-
-  const opened = await waitForStableWindow(options, 'opened-conversation', { attempts: 6, delayMs: 800 })
-  artifacts.push(opened.file)
-  const titleOcr = await recognizeScreenshot(opened, options, 'title-confirmation')
-  const titleConfirmed = Boolean(findTitleConfirmation(titleOcr.observations, options.group))
-  if (!titleConfirmed) {
-    // Some OCR models miss the top title but the click may still be correct. Keep the debug capture and continue
-    // only if the caller explicitly opted out of strict confirmation.
-    if (!options.allowWeakTitle) throw new Error(`Opened conversation title was not confirmed as '${options.group}'. See ${opened.file}`)
-  }
-  opened.openEvidence = {
-    strategy: 'search',
-    searchUsed: true,
-    leftListUsed: false,
-    titleConfirmed,
-    targetText: observationText(target),
-  }
-  return opened
-}
-
-export function buildActionEvidence({ options = {}, opened = {}, sent = [], downloads = [], postRunSafety = {}, artifacts = [], layout = {} } = {}) {
-  const confirmationMethods = []
-  for (const item of Array.isArray(sent) ? sent : []) {
-    if (item?.confirmationMethod) confirmationMethods.push(item.confirmationMethod)
-    if (Array.isArray(item?.confirmationMethods)) confirmationMethods.push(...item.confirmationMethods)
-  }
-  const downloadStrategies = Array.from(new Set((Array.isArray(downloads) ? downloads : [])
-    .map(item => item?.strategy)
-    .filter(Boolean)))
-  const openEvidence = opened?.openEvidence || {}
-  return {
-    targetGroup: options.group || '',
-    openStrategy: openEvidence.strategy || 'unknown',
-    searchUsed: Boolean(openEvidence.searchUsed),
-    leftListUsed: Boolean(openEvidence.leftListUsed),
-    titleConfirmed: Boolean(openEvidence.titleConfirmed),
-    searchOpenAllowed: Boolean(options.allowSearchOpen),
-    rightClickDownloadAllowed: Boolean(options.allowRightClickDownload),
-    rightClickUsed: downloadStrategies.includes('right-click-copy'),
-    downloadStrategies,
-    sentTypes: (Array.isArray(sent) ? sent : []).map(item => item?.type).filter(Boolean),
-    confirmationMethods: Array.from(new Set(confirmationMethods)),
-    postRunSafetyOk: postRunSafety?.ok === true,
-    postRunSafetyArtifact: postRunSafety?.artifact || '',
-    artifactCount: Array.isArray(artifacts) ? artifacts.length : 0,
-    layout: {
-      currentTitle: layout?.currentTitle || '',
-      messageCount: Number(layout?.messageCount || 0),
-      attachmentCount: Number(layout?.attachmentCount || 0),
-      hasInputBox: Boolean(layout?.inputBox),
-      hasMessageArea: Boolean(layout?.messageArea),
-    },
-  }
-}
-
-export async function runVisualFlow(input) {
-  const captureDir = path.resolve(input.captureDir || fs.mkdtempSync(path.join(fs.realpathSync(process.env.TEMP || process.env.TMP || '/tmp'), 'shennian-wechat-rpa-win-visual-')))
-  prepareCaptureDir(captureDir)
-  const options = {
-    ...input,
-    captureDir,
-    step: 1,
-    recentLimit: Math.max(Number(input.recentLimit || 5), input.downloadAttachmentsDir && input.downloadAttachments !== false ? 20 : 0),
-    ocrTimeoutMs: Number(input.ocrTimeoutMs || 45_000),
-    openTimeoutMs: Number(input.openTimeoutMs || 12_000),
-  }
-  if (!options.group) throw new Error('--group is required')
-  const artifacts = []
-
-  const opened = await openConversationBySearch(options, artifacts)
-  const messageCapture = await capture('messages', options, 'messages-before-send')
-  artifacts.push(messageCapture.file)
-  const messageOcr = await recognizeScreenshot(messageCapture, options, 'message-read')
-  let recentMessages = summarizeObservations(messageOcr.observations, options.recentLimit)
-  recentMessages = mergeRecentMessagesWithAttachments(
-    recentMessages,
-    summarizeAttachmentObservations(messageOcr.observations, options.recentLimit),
-    options.recentLimit,
-  )
-  const localization = await localizeInboundAttachments(recentMessages, messageCapture, options)
-  recentMessages = localization.recentMessages
-
-  const sent = []
-  if (!options.dryRun && (options.replyText || options.files?.length)) {
-    await assertComposerEmptyBeforeSend(options, artifacts)
-  }
-  if (!options.dryRun && options.replyText) {
-    await click(geometryPoint(opened.payload, 'input'), options)
-    await pasteText(options.replyText, options)
-    await sleep(250)
-    await press('{ENTER}', options)
-    await sleep(900)
-    const confirmCapture = await capture('window', options, 'after-text-send')
-    artifacts.push(confirmCapture.file)
-    const confirmOcr = await recognizeScreenshot(confirmCapture, options, 'send-confirmation')
-    const confirmation = await confirmSentText(confirmOcr, options.replyText, opened, confirmCapture)
-    if (!confirmation.observation) {
-      throw new Error(`Sent text was not confirmed by OCR or outbound bubble diff: '${options.replyText}'. See ${confirmCapture.file}`)
-    }
-    sent.push({
-      type: 'text',
-      text: options.replyText,
-      confirmationMethod: confirmation.method,
-      observations: summarizeObservations([confirmation.observation], options.recentLimit),
-    })
-  }
-
-  if (!options.dryRun && options.files?.length) {
-    const confirmedFiles = []
-    const sentAttachments = []
-    const confirmationObservations = []
-    const confirmationMethods = []
-    for (const [index, file] of options.files.entries()) {
-      let pendingCapture = null
-      let pendingOcr = null
-      let sendButton = null
-      for (let attempt = 1; attempt <= 2; attempt += 1) {
-        await click(geometryPoint(opened.payload, 'fileInput'), options)
-        await sleep(120)
-        await pasteFiles([file], options)
-        await sleep(950)
-        pendingCapture = await captureWithRetry('window', options, `pending-file-${index + 1}${attempt > 1 ? `-retry-${attempt}` : ''}`, { attempts: 8, delayMs: 900 })
-        artifacts.push(pendingCapture.file)
-        pendingOcr = await recognizeScreenshot(pendingCapture, options, 'send-button')
-        sendButton = findSendButtonObservation(pendingOcr.observations)
-        if (sendButton || missingConfirmedFiles(pendingOcr.observations, [file]).length === 0) break
-      }
-      if (!pendingCapture || !pendingOcr) throw new Error(`File was not captured after paste: ${basenameForAnyPlatform(file)}`)
-      if (!sendButton && missingConfirmedFiles(pendingOcr.observations, [file]).length > 0) {
-        throw new Error(`File did not appear in the WeChat composer after paste: ${basenameForAnyPlatform(file)}. See ${pendingCapture.file}`)
-      }
-      if (sendButton) {
-        await click(pointFromObservation(pendingCapture.payload, sendButton, pendingCapture.imageSize), options)
-      } else {
-        await press('{ENTER}', options)
-      }
-      await sleep(postPasteDelayMs(file))
-      const fileConfirmCapture = await capture('window', options, `after-file-${index + 1}-send`)
-      artifacts.push(fileConfirmCapture.file)
-      const fileConfirmOcr = await recognizeScreenshot(fileConfirmCapture, options, 'send-confirmation')
-      const missing = missingConfirmedFiles(fileConfirmOcr.observations, [file])
-      if (missing.length > 0) {
-        const visual = await detectNewOutboundAttachmentBubble(attachmentVisualBeforeFile(opened, pendingCapture), fileConfirmCapture.file)
-        if (!visual?.ok) {
-          throw new Error(`Sent file was not confirmed by OCR or outbound attachment diff: ${basenameForAnyPlatform(file)}. See ${fileConfirmCapture.file}`)
-        }
-        confirmationMethods.push('visual-new-outbound-attachment')
-        confirmationObservations.push({
-          text: basenameForAnyPlatform(file),
-          role: 'outbound-visual',
-          confidence: 0,
-          box: visual.box,
-          visual,
-        })
-      } else {
-        confirmationMethods.push('ocr-file-name')
-        confirmationObservations.push(...summarizeObservations(fileConfirmOcr.observations, options.recentLimit))
-      }
-      confirmedFiles.push(file)
-      sentAttachments.push(classifyOutboundFile(file))
-    }
-    sent.push({
-      type: 'files',
-      files: confirmedFiles,
-      confirmationMethods,
-      attachments: sentAttachments,
-      observations: confirmationObservations.slice(-options.recentLimit),
-    })
-  }
-
-  const postRunSafety = await verifyPostRunSafety(options, artifacts)
-
-  const layoutSummary = summarizeCoreLayout(messageOcr.layout)
-  const summary = {
-    ok: true,
-    group: options.group,
-    captureDir,
-    ocrEvidence: summarizeOcrEvidence(messageOcr),
-    layout: layoutSummary,
-    recentMessages,
-    downloads: localization.downloads,
-    sent,
-    postRunSafety,
-    artifacts,
-  }
-  summary.actionEvidence = buildActionEvidence({
-    options,
-    opened,
-    sent,
-    downloads: localization.downloads,
-    postRunSafety,
-    artifacts,
-    layout: layoutSummary,
-  })
-  fs.writeFileSync(path.join(captureDir, 'summary.json'), `${JSON.stringify(summary, null, 2)}\n`)
-  return summary
-}
-
-async function main() {
-  const argv = process.argv.slice(2)
-  if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {
-    printHelp()
-    return
-  }
-  const files = takeMany(argv, '--file')
-  const options = {
-    group: takeOption(argv, '--group'),
-    replyText: takeOption(argv, '--reply-text'),
-    recentLimit: takeOption(argv, '--recent-limit') || '5',
-    captureDir: takeOption(argv, '--capture-dir'),
-    downloadAttachmentsDir: takeOption(argv, '--download-attachments-dir'),
-    downloadExpectedTokens: takeMany(argv, '--download-expected-token'),
-    downloadLimit: takeOption(argv, '--download-limit'),
-    allowRightClickDownload: takeFlag(argv, '--allow-right-click-download'),
-    allowSearchOpen: takeFlag(argv, '--allow-search-open'),
-    ocrUrl: takeOption(argv, '--ocr-url'),
-    token: takeOption(argv, '--token'),
-    ocrFixture: takeOption(argv, '--ocr-fixture'),
-    helper: takeOption(argv, '--helper'),
-    channelId: takeOption(argv, '--channel-id'),
-    ocrTimeoutMs: Number(takeOption(argv, '--ocr-timeout-ms') || 45_000),
-    openTimeoutMs: Number(takeOption(argv, '--open-timeout-ms') || 12_000),
-    allowWeakTitle: takeFlag(argv, '--allow-weak-title'),
-    downloadAttachments: !takeFlag(argv, '--no-download-attachments'),
-    dryRun: takeFlag(argv, '--dry-run'),
-    files,
-  }
-  if (argv.length) throw new Error(`Unknown arguments: ${argv.join(' ')}`)
-  const summary = await runVisualFlow(options)
-  process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`)
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  main().catch(error => {
-    console.error(error instanceof Error ? error.message : String(error))
-    process.exit(1)
-  })
-}