shennian 0.2.77 → 0.2.83

package/dist/src/channels/wechat-rpa.js

@@ -4,6 +4,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { ChannelSecretRegistry } from './secret-registry.js';
 import { probeMacWeChat, observedMessageFromProbe } from './wechat-rpa/macos.js';
 import { runMacWeChatRpaFlow } from './wechat-rpa/macos-flow.js';
@@ -11,9 +12,14 @@ import { runWindowsWeChatRpaVisualFlow } from './wechat-rpa/windows-visual-flow.
 import { normalizeWeChatRpaMessage, WeChatRpaDeduper, weChatRpaConversationId, } from './wechat-rpa/normalizer.js';
 const DEFAULT_POLL_INTERVAL_MS = 5_000;
 const DEFAULT_RECENT_LIMIT = 5;
+const LAB_SCROLL_READ_RECENT_LIMIT = 8;
 const MAX_OUTBOUND_ATTACHMENT_BYTES = Number(process.env.SHENNIAN_WECHAT_RPA_OUTBOUND_ATTACHMENT_MAX_BYTES || 20 * 1024 * 1024);
 const INTERRUPTION_COOLDOWN_THRESHOLD = Number(process.env.SHENNIAN_WECHAT_RPA_INTERRUPTION_COOLDOWN_THRESHOLD || 3);
 const INTERRUPTION_COOLDOWN_MS = Number(process.env.SHENNIAN_WECHAT_RPA_INTERRUPTION_COOLDOWN_MS || 5 * 60 * 1000);
+const MAX_RECENT_TASK_SUMMARIES = 10;
+export function selectWeChatRpaLabReadKind(recentLimit) {
+    return clampNumber(recentLimit, DEFAULT_RECENT_LIMIT, 1, 50) >= LAB_SCROLL_READ_RECENT_LIMIT ? 'scroll-read' : 'read-latest';
+}
 export class WeChatRpaChannelAdapter {
     onMessage;
     type = 'wechat-rpa';
@@ -66,7 +72,7 @@ export class WeChatRpaChannelAdapter {
         if (secret.canReply === false)
             throw new Error('WeChat RPA channel does not allow replies');
         if (!isFlowSource(secret.source)) {
-            throw new Error('WeChat RPA reply requires source=macos-flow or windows-visual-flow');
+            throw new Error('WeChat RPA reply requires source=macos-flow, windows-visual-flow, or wechat-rpa-lab');
         }
         const conn = this.ensureConnection(config);
         conn.config = config;
@@ -79,6 +85,9 @@ export class WeChatRpaChannelAdapter {
         const pendingKey = pendingReplyKey(config, reply);
         if (conn.completedPendingReplyKeys.has(pendingKey))
             return { status: 'sent' };
+        const manualReview = conn.manualReviewReplies.get(pendingKey);
+        if (manualReview)
+            return { status: 'manual-review', reason: manualReview.reason };
         const attachmentPath = reply.attachment
             ? await materializeWeChatRpaOutboundAttachment(config.workDir, reply.attachment)
             : undefined;
@@ -103,13 +112,19 @@ export class WeChatRpaChannelAdapter {
             conn.runtimeState = 'syncing';
             flow = await this.enqueueOperation(conn, () => {
                 conn.lastRunAt = new Date().toISOString();
-                return runSendFlow(config, secret, conversationName, text, attachmentPath);
+                return runSendFlow(config, secret, conversationName, text, attachmentPath, pendingKey);
             });
         }
         catch (error) {
             conn.lastError = error instanceof Error ? error.message : String(error);
+            addTaskSummary(conn, {
+                status: classifyWeChatRpaFailure(conn.lastError),
+                runId: conn.lastRunId ?? null,
+                summary: conn.lastError,
+            });
             throw error;
         }
+        recordTraceRuntime(conn, flow);
         const partial = applyPartialSendProgress(flow, { text, attachmentPath });
         if (partial.status === 'queued') {
             const reason = partial.reason;
@@ -139,9 +154,17 @@ export class WeChatRpaChannelAdapter {
             });
             return { status: 'queued', reason };
         }
-        if (!flow.ok)
-            throw new Error(flow.error || 'WeChat RPA send failed');
+        if (!flow.ok) {
+            const reason = flow.error || 'WeChat RPA send validator failed; manual review required before retry';
+            noteManualReview(conn, pendingKey, reason);
+            return { status: 'manual-review', reason };
+        }
         recordCloudOcrRuntime(conn, flow);
+        addTaskSummary(conn, {
+            status: 'sent',
+            runId: conn.lastRunId ?? null,
+            summary: flow.rpaTraceSummary || `sent ${conversationName}`,
+        });
         noteSuccessfulRun(conn);
         conn.lastError = null;
         return { status: 'sent' };
@@ -159,6 +182,19 @@ export class WeChatRpaChannelAdapter {
             if (!configuredGroups(secret).length)
                 return { ok: false, message: 'WeChat RPA macOS flow requires at least one group' };
         }
+        if (secret.source === 'wechat-rpa-lab') {
+            if (process.platform !== 'darwin')
+                return { ok: false, message: 'WeChat RPA Lab source requires macOS for live runs' };
+            if (!configuredGroups(secret).length)
+                return { ok: false, message: 'WeChat RPA Lab source requires at least one group' };
+            try {
+                resolveWeChatRpaLabIndex(config.workDir);
+            }
+            catch (error) {
+                return { ok: false, message: error instanceof Error ? error.message : String(error) };
+            }
+            return { ok: true, message: 'WeChat RPA Lab source configured' };
+        }
         if (secret.source === 'windows-visual-flow') {
             return windowsVisualFlowHealth(secret, process.platform);
         }
@@ -185,6 +221,10 @@ export class WeChatRpaChannelAdapter {
             wechatRpaLastInterruptedAt: conn.lastInterruptedAt ?? null,
             wechatRpaPendingReplyCount: conn.pendingReplies.size,
             wechatRpaLastError: conn.lastError ?? null,
+            wechatRpaLastRunId: conn.lastRunId ?? null,
+            wechatRpaLastTracePath: conn.lastTracePath ?? null,
+            wechatRpaLastTraceSummary: conn.lastTraceSummary ?? null,
+            wechatRpaRecentTaskSummaries: conn.recentTaskSummaries,
             wechatRpaLastCloudOcrAt: conn.lastCloudOcrAt ?? null,
             wechatRpaLastCloudOcrPurpose: conn.lastCloudOcrPurpose ?? null,
             wechatRpaLastCloudOcrRequestId: conn.lastCloudOcrRequestId ?? null,
@@ -202,10 +242,12 @@ export class WeChatRpaChannelAdapter {
                 stopped: false,
                 conversations: new Map(),
                 pendingReplies: new Map(),
+                manualReviewReplies: new Map(),
                 completedPendingReplyKeys: new Set(),
                 pendingStatePath: undefined,
                 messageStatePath: undefined,
                 operation: Promise.resolve(),
+                recentTaskSummaries: [],
                 runtimeState: 'idle_waiting',
                 consecutiveInterruptions: 0,
             };
@@ -241,6 +283,7 @@ export class WeChatRpaChannelAdapter {
             let interrupted = false;
             conn.runtimeState = 'syncing';
             const observed = await this.readObservedMessages(conn.config, secret, (flow) => {
+                recordTraceRuntime(conn, flow);
                 recordCloudOcrRuntime(conn, flow);
                 if (!flow.interrupted)
                     return;
@@ -249,7 +292,7 @@ export class WeChatRpaChannelAdapter {
             });
             conn.lastError = null;
             for (const item of observed) {
-                const message = normalizeWeChatRpaMessage(item);
+                const message = normalizeWeChatRpaMessage(item, { selfNicknames: wechatRpaSelfNicknames(secret) });
                 if (!message || !conn.deduper.accept(message.messageId))
                     continue;
                 persistMessageState(conn);
@@ -261,15 +304,22 @@ export class WeChatRpaChannelAdapter {
                     channelId: conn.config.id,
                     channelType: 'wechat-rpa',
                     conversationId: message.conversationId,
+                    conversationName: message.conversationName,
                     messageId: message.messageId,
                     sender: message.sender,
                     text: message.text,
                     attachments: message.attachments,
                     receivedAt: message.receivedAt,
+                    isMentioned: message.isMentioned,
                     replyTarget: '',
                     rawRef: message.rawRef,
                 };
                 emitted.push(this.onMessage?.(event) ?? event);
+                addTaskSummary(conn, {
+                    status: 'received',
+                    runId: conn.lastRunId ?? null,
+                    summary: `received ${message.conversationName}${message.sender.name ? ` from ${message.sender.name}` : ''}: ${clipSummary(message.text || message.attachments[0]?.name || 'attachment')}`,
+                });
             }
             if (!interrupted)
                 noteSuccessfulRun(conn);
@@ -277,6 +327,11 @@ export class WeChatRpaChannelAdapter {
         }
         catch (error) {
             conn.lastError = error instanceof Error ? error.message : String(error);
+            addTaskSummary(conn, {
+                status: classifyWeChatRpaFailure(conn.lastError),
+                runId: conn.lastRunId ?? null,
+                summary: conn.lastError,
+            });
             throw error;
         }
     }
@@ -288,7 +343,8 @@ export class WeChatRpaChannelAdapter {
             pending.attempts += 1;
             pending.lastAttemptAt = new Date().toISOString();
             persistPendingReplyState(conn);
-            const flow = await runSendFlow(conn.config, secret, pending.conversationName, pending.skipText ? '' : pending.text, pending.attachmentPath);
+            const flow = await runSendFlow(conn.config, secret, pending.conversationName, pending.skipText ? '' : pending.text, pending.attachmentPath, pending.key);
+            recordTraceRuntime(conn, flow);
             recordCloudOcrRuntime(conn, flow);
             const partial = applyPartialSendProgress(flow, {
                 text: pending.skipText ? '' : pending.text,
@@ -313,12 +369,22 @@ export class WeChatRpaChannelAdapter {
                 persistPendingReplyState(conn);
                 return true;
             }
-            if (!flow.ok)
-                throw new Error(flow.error || 'WeChat RPA pending send failed');
+            if (!flow.ok) {
+                const reason = flow.error || 'WeChat RPA pending send validator failed; manual review required before retry';
+                conn.pendingReplies.delete(pending.key);
+                noteManualReview(conn, pending.key, reason);
+                persistPendingReplyState(conn);
+                return true;
+            }
             conn.pendingReplies.delete(pending.key);
             conn.completedPendingReplyKeys.add(pending.key);
             persistPendingReplyState(conn);
             conn.lastError = null;
+            addTaskSummary(conn, {
+                status: 'sent',
+                runId: conn.lastRunId ?? null,
+                summary: flow.rpaTraceSummary || `sent ${pending.conversationName}`,
+            });
             noteSuccessfulRun(conn);
         }
         return false;
@@ -330,6 +396,9 @@ export class WeChatRpaChannelAdapter {
         if (secret.source === 'macos-flow') {
             return readMacFlowMessages(config, secret, onFlow);
         }
+        if (secret.source === 'wechat-rpa-lab') {
+            return readLabMessages(config, secret, onFlow);
+        }
         if (secret.source === 'windows-visual-flow') {
             return readWindowsVisualFlowMessages(config, secret, onFlow);
         }
@@ -360,6 +429,20 @@ function configuredGroups(secret) {
         ? secret.groups.map((group) => String(group?.name || '').trim()).filter(Boolean)
         : [];
 }
+function wechatRpaSelfNicknames(secret) {
+    return String(secret.selfNickname || '')
+        .split(/[,\n，、]/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function isWeChatRpaTextMentioned(text, aliases) {
+    if (!aliases.length)
+        return false;
+    return aliases.some((alias) => {
+        const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return new RegExp(`@\\s*${escaped}(?=$|\\s|[，。！？,.!?:：；;、)])`).test(text);
+    });
+}
 export function windowsVisualFlowHealth(secret, platform = process.platform) {
     if (platform !== 'win32')
         return { ok: false, message: 'WeChat RPA Windows visual flow requires Windows' };
@@ -368,6 +451,173 @@ export function windowsVisualFlowHealth(secret, platform = process.platform) {
     }
     return { ok: true, message: 'WeChat RPA Windows visual flow configured' };
 }
+async function readLabMessages(config, secret, onFlow) {
+    const api = await importWeChatRpaLabApi(config.workDir);
+    const result = [];
+    for (const name of configuredGroups(secret)) {
+        const flow = await runLabReadFlow(api, secret, name);
+        onFlow?.(flow);
+        if (!flow.ok || flow.interrupted)
+            continue;
+        for (const message of flow.newMessages ?? []) {
+            const observed = flowMessageToObservedMessage(name, message, secret);
+            if (observed)
+                result.push(observed);
+        }
+    }
+    return result;
+}
+async function runLabReadFlow(api, secret, groupName) {
+    const kind = selectWeChatRpaLabReadKind(secret.recentLimit);
+    const task = {
+        kind,
+        requestId: `wechat-rpa:${groupName}:read:${Date.now()}`,
+        targetGroup: groupName,
+        policy: secret.forceForeground ? 'work' : 'polite',
+        limit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 1, 50),
+        readMode: secret.readMode === 'hybrid-vlm' ? 'hybrid-vlm' : 'local-ocr',
+    };
+    const result = await api.runWechatRpaReadLatest(task);
+    const structuredMessages = Array.isArray(result.data?.structuredMessages) ? result.data.structuredMessages : [];
+    const latestMessages = result.validation?.deterministic?.latestMessages ?? [];
+    const flowMessages = structuredMessages.length
+        ? structuredMessages.map((message, index) => structuredMessageToFlowMessage(message, result.runId || 'lab-read', index))
+        : latestMessages.map((text, index) => ({
+            id: `${result.runId || 'lab-read'}:${index}`,
+            text,
+            confidence: 0.8,
+        }));
+    return {
+        ok: Boolean(result.ok),
+        groupName,
+        interrupted: result.status === 'interrupted',
+        reason: result.status,
+        rpaRunId: result.runId,
+        rpaTraceSummary: `${kind} ${result.status || (result.ok ? 'success' : 'failed')} ${groupName}`,
+        recentMessages: flowMessages,
+        newMessages: flowMessages,
+        screenshotPath: result.tracePath,
+        cloudOcrUsage: result.data?.hybrid?.usage,
+        error: labResultError(result),
+    };
+}
+function structuredMessageToFlowMessage(message, runId, index) {
+    return {
+        id: `${runId}:${message.index ?? index}`,
+        text: String(message.text || message.card?.title || '').trim(),
+        confidence: typeof message.confidence === 'number' ? message.confidence : 0.75,
+        senderName: typeof message.senderName === 'string' ? message.senderName : null,
+        attachments: structuredAttachments(message),
+    };
+}
+function structuredAttachments(message) {
+    const kind = String(message.kind || '');
+    if (!['image', 'file', 'video-file', 'video-card', 'link-card', 'official-account-card', 'mini-program-card'].includes(kind))
+        return [];
+    const localPath = typeof message.localPath === 'string' ? message.localPath : undefined;
+    const attachmentType = kind === 'video-file' || kind === 'video-card' ? 'video' : kind === 'link-card' || kind === 'official-account-card' || kind === 'mini-program-card' ? 'file' : kind;
+    return [{
+            type: attachmentType,
+            localPath,
+            availability: localPath ? 'edge-local' : 'metadata-only',
+        }];
+}
+async function runLabSendFlow(config, secret, conversationName, text, attachmentPath, dedupeKey) {
+    const api = await importWeChatRpaLabApi(config.workDir);
+    const tasks = planWeChatRpaLabSendTasks({
+        groupName: conversationName,
+        text,
+        attachmentPath,
+        dedupeKey,
+        requestId: dedupeKey,
+        policy: 'work',
+    });
+    const results = [];
+    for (const task of tasks) {
+        const result = await api.runWechatRpaTask(task);
+        results.push(result);
+        if (!result.ok)
+            break;
+    }
+    const textResult = results.find((result) => result.kind === 'send-text');
+    const attachmentResult = results.find((result) => result.kind === 'send-image' || result.kind === 'send-video' || result.kind === 'send-file');
+    const ok = tasks.length > 0 && results.length === tasks.length && results.every((result) => result.ok);
+    const interrupted = results.some((result) => result.status === 'interrupted');
+    return {
+        ok,
+        groupName: conversationName,
+        interrupted,
+        reason: results.at(-1)?.status,
+        rpaRunId: results.at(-1)?.runId,
+        rpaTraceSummary: `send ${ok ? 'success' : results.at(-1)?.status || 'failed'} ${conversationName} (${results.length}/${tasks.length})`,
+        sentReply: Boolean(text),
+        sentReplyObserved: text ? Boolean(textResult?.ok) : false,
+        sentAttachment: Boolean(attachmentPath),
+        sentAttachmentObserved: attachmentPath ? Boolean(attachmentResult?.ok) : false,
+        postSendScreenshotPath: results.at(-1)?.tracePath,
+        error: ok ? undefined : labResultError(results.at(-1)),
+    };
+}
+export function planWeChatRpaLabSendTasks(input) {
+    const tasks = [];
+    const text = String(input.text || '').trim();
+    const policy = input.policy || 'work';
+    if (text) {
+        tasks.push({
+            kind: 'send-text',
+            requestId: input.requestId ? `${input.requestId}:text` : undefined,
+            targetGroup: input.groupName,
+            policy,
+            text,
+            ...(input.dedupeKey ? { dedupeKey: `${input.dedupeKey}:text` } : {}),
+        });
+    }
+    if (input.attachmentPath) {
+        const kind = weChatRpaLabTaskKindForAttachment(input.attachmentPath);
+        tasks.push({
+            kind,
+            requestId: input.requestId ? `${input.requestId}:attachment` : undefined,
+            targetGroup: input.groupName,
+            policy,
+            filePath: input.attachmentPath,
+            ...(input.dedupeKey ? { dedupeKey: `${input.dedupeKey}:attachment` } : {}),
+        });
+    }
+    return tasks;
+}
+export function weChatRpaLabTaskKindForAttachment(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (['.png', '.jpg', '.jpeg', '.gif', '.webp', '.heic'].includes(ext))
+        return 'send-image';
+    if (['.mp4', '.mov', '.avi', '.mkv'].includes(ext))
+        return 'send-video';
+    return 'send-file';
+}
+async function importWeChatRpaLabApi(workDir) {
+    const modulePath = resolveWeChatRpaLabIndex(workDir);
+    return await import(pathToFileURL(modulePath).href);
+}
+function resolveWeChatRpaLabIndex(workDir) {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        process.env.SHENNIAN_WECHAT_RPA_LAB_INDEX,
+        path.resolve(moduleDir, '../../../../scripts/wechat-rpa-lab/index.mjs'),
+        workDir ? path.join(workDir, 'scripts/wechat-rpa-lab/index.mjs') : '',
+        path.resolve(process.cwd(), 'scripts/wechat-rpa-lab/index.mjs'),
+    ].filter(Boolean);
+    const found = candidates.find((candidate) => fs.existsSync(candidate));
+    if (!found) {
+        throw new Error('WeChat RPA Lab API is missing; set SHENNIAN_WECHAT_RPA_LAB_INDEX or run from the repository root');
+    }
+    return path.resolve(found);
+}
+function labResultError(result) {
+    if (!result)
+        return 'WeChat RPA Lab did not return a result';
+    if (typeof result.error === 'string')
+        return result.error;
+    return result.error?.message || (result.ok ? undefined : `WeChat RPA Lab task ${result.kind || '<unknown>'} ${result.status || 'failed'}`);
+}
 async function readMacFlowMessages(config, secret, onFlow) {
     const result = [];
     for (const name of configuredGroups(secret)) {
@@ -380,27 +630,15 @@ async function readMacFlowMessages(config, secret, onFlow) {
             idleSeconds: clampNumber(secret.idleSeconds, 15, 0, 3600),
             recentLimit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 0, 50),
             downloadAttachmentsDir: resolveInboundAttachmentDir(config.workDir, secret),
-            cloudOcrUrl: typeof secret.cloudOcrUrl === 'string' ? secret.cloudOcrUrl : undefined,
-            cloudOcrToken: typeof secret.cloudOcrToken === 'string' ? secret.cloudOcrToken : undefined,
-            cloudOcrMode: normalizeCloudOcrMode(secret.cloudOcrMode),
-            cloudOcrChannelId: config.id,
+            cloudOcrMode: 'off',
         });
         onFlow?.(flow);
         if (flow.interrupted)
             continue;
         for (const message of flow.newMessages ?? []) {
-            const text = String(message.text || '').trim();
-            const attachments = Array.isArray(message.attachments) ? message.attachments : [];
-            if (!text && attachments.length === 0)
-                continue;
-            result.push({
-                conversationName: name,
-                senderName: null,
-                text,
-                attachments: annotateWeChatRpaInboundAttachments(attachments),
-                observedAt: new Date().toISOString(),
-                rawId: String(message.id || `${name}:${text}`),
-            });
+            const observed = flowMessageToObservedMessage(name, message, secret);
+            if (observed)
+                result.push(observed);
         }
     }
     return result;
@@ -414,32 +652,37 @@ async function readWindowsVisualFlowMessages(config, secret, onFlow) {
             workDir: config.workDir,
             recentLimit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 0, 50),
             downloadAttachmentsDir: resolveInboundAttachmentDir(config.workDir, secret),
-            cloudOcrUrl: typeof secret.cloudOcrUrl === 'string' ? secret.cloudOcrUrl : undefined,
-            cloudOcrToken: typeof secret.cloudOcrToken === 'string' ? secret.cloudOcrToken : undefined,
-            cloudOcrMode: normalizeCloudOcrMode(secret.cloudOcrMode),
-            cloudOcrChannelId: config.id,
+            cloudOcrMode: 'off',
         });
         onFlow?.(flow);
         if (flow.interrupted)
             continue;
         for (const message of flow.newMessages ?? []) {
-            const text = String(message.text || '').trim();
-            const attachments = Array.isArray(message.attachments) ? message.attachments : [];
-            if (!text && attachments.length === 0)
-                continue;
-            result.push({
-                conversationName: name,
-                senderName: null,
-                text,
-                attachments: annotateWeChatRpaInboundAttachments(attachments),
-                observedAt: new Date().toISOString(),
-                rawId: String(message.id || `${name}:${text}`),
-            });
+            const observed = flowMessageToObservedMessage(name, message, secret);
+            if (observed)
+                result.push(observed);
         }
     }
     return result;
 }
-async function runSendFlow(config, secret, conversationName, text, attachmentPath) {
+function flowMessageToObservedMessage(conversationName, message, secret) {
+    const text = String(message.text || '').trim();
+    const attachments = Array.isArray(message.attachments) ? message.attachments : [];
+    if (!text && attachments.length === 0)
+        return null;
+    const senderName = typeof message.senderName === 'string' ? message.senderName.trim() : '';
+    const observedAt = String(message.observedAt || message.timestampIso || '').trim() || new Date().toISOString();
+    return {
+        conversationName,
+        senderName: senderName || null,
+        text,
+        attachments: annotateWeChatRpaInboundAttachments(attachments),
+        observedAt,
+        isMentioned: message.isMentioned === true || isWeChatRpaTextMentioned(text, wechatRpaSelfNicknames(secret)),
+        rawId: String(message.id || `${conversationName}:${senderName}:${text}:${observedAt}`),
+    };
+}
+async function runSendFlow(config, secret, conversationName, text, attachmentPath, dedupeKey) {
     if (secret.source === 'windows-visual-flow') {
         return runWindowsWeChatRpaVisualFlow({
             groupName: conversationName,
@@ -449,12 +692,12 @@ async function runSendFlow(config, secret, conversationName, text, attachmentPat
             workDir: config.workDir,
             recentLimit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 0, 50),
             downloadAttachmentsDir: resolveInboundAttachmentDir(config.workDir, secret),
-            cloudOcrUrl: typeof secret.cloudOcrUrl === 'string' ? secret.cloudOcrUrl : undefined,
-            cloudOcrToken: typeof secret.cloudOcrToken === 'string' ? secret.cloudOcrToken : undefined,
-            cloudOcrMode: normalizeCloudOcrMode(secret.cloudOcrMode),
-            cloudOcrChannelId: config.id,
+            cloudOcrMode: 'off',
         });
     }
+    if (secret.source === 'wechat-rpa-lab') {
+        return runLabSendFlow(config, secret, conversationName, text, attachmentPath, dedupeKey);
+    }
     return runMacWeChatRpaFlow({
         groupName: conversationName,
         replyText: text || undefined,
@@ -466,14 +709,11 @@ async function runSendFlow(config, secret, conversationName, text, attachmentPat
         idleSeconds: clampNumber(secret.idleSeconds, 15, 0, 3600),
         recentLimit: clampNumber(secret.recentLimit, DEFAULT_RECENT_LIMIT, 0, 50),
         downloadAttachmentsDir: resolveInboundAttachmentDir(config.workDir, secret),
-        cloudOcrUrl: typeof secret.cloudOcrUrl === 'string' ? secret.cloudOcrUrl : undefined,
-        cloudOcrToken: typeof secret.cloudOcrToken === 'string' ? secret.cloudOcrToken : undefined,
-        cloudOcrMode: normalizeCloudOcrMode(secret.cloudOcrMode),
-        cloudOcrChannelId: config.id,
+        cloudOcrMode: 'off',
     });
 }
 function isFlowSource(source) {
-    return source === 'macos-flow' || source === 'windows-visual-flow';
+    return source === 'macos-flow' || source === 'windows-visual-flow' || source === 'wechat-rpa-lab';
 }
 function applyPartialSendProgress(flow, input) {
     if (input.text && input.attachmentPath && flow.sentReplyObserved && !flow.sentAttachmentObserved) {
@@ -516,6 +756,20 @@ function enqueuePendingReply(conn, input) {
     });
     persistPendingReplyState(conn);
 }
+function noteManualReview(conn, key, reason) {
+    conn.manualReviewReplies.set(key, {
+        key,
+        reason,
+        createdAt: conn.manualReviewReplies.get(key)?.createdAt ?? new Date().toISOString(),
+    });
+    conn.lastError = reason;
+    addTaskSummary(conn, {
+        status: 'failed',
+        runId: conn.lastRunId ?? null,
+        summary: `manual review required: ${reason}`,
+    });
+    persistPendingReplyState(conn);
+}
 function hydratePendingReplyState(conn, config) {
     const filePath = pendingReplyStatePath(config);
     if (conn.pendingStatePath === filePath)
@@ -528,6 +782,12 @@ function hydratePendingReplyState(conn, config) {
         if (!conn.pendingReplies.has(pending.key))
             conn.pendingReplies.set(pending.key, pending);
     }
+    for (const item of store.manualReview ?? []) {
+        if (!isManualReviewRecord(item))
+            continue;
+        if (!conn.manualReviewReplies.has(item.key))
+            conn.manualReviewReplies.set(item.key, item);
+    }
     for (const key of store.completedKeys ?? []) {
         if (typeof key === 'string' && key)
             conn.completedPendingReplyKeys.add(key);
@@ -538,9 +798,10 @@ function persistPendingReplyState(conn) {
         return;
     const completedKeys = Array.from(conn.completedPendingReplyKeys).slice(-500);
     const pending = Array.from(conn.pendingReplies.values()).slice(0, 500);
+    const manualReview = Array.from(conn.manualReviewReplies.values()).slice(-500);
     try {
         fs.mkdirSync(path.dirname(conn.pendingStatePath), { recursive: true });
-        fs.writeFileSync(conn.pendingStatePath, JSON.stringify({ version: 1, pending, completedKeys }, null, 2));
+        fs.writeFileSync(conn.pendingStatePath, JSON.stringify({ version: 1, pending, manualReview, completedKeys }, null, 2));
     }
     catch {
         // Runtime state is best-effort; the in-memory queue still protects the current daemon.
@@ -569,6 +830,14 @@ function isPendingReplyRecord(value) {
         && (record.attachmentPath === undefined || typeof record.attachmentPath === 'string')
         && (record.skipText === undefined || typeof record.skipText === 'boolean');
 }
+function isManualReviewRecord(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    return typeof record.key === 'string'
+        && typeof record.reason === 'string'
+        && typeof record.createdAt === 'string';
+}
 function pendingReplyStatePath(config) {
     const id = crypto.createHash('sha256').update(config.id).digest('hex').slice(0, 16);
     return path.join(config.workDir, '.shennian', 'wechat-rpa-pending-replies', `${id}.json`);
@@ -615,6 +884,11 @@ function noteInterruption(conn, flow, reason) {
         conn.runtimeState = 'cooldown';
     }
     recordCloudOcrRuntime(conn, flow);
+    addTaskSummary(conn, {
+        status: 'interrupted',
+        runId: flow.rpaRunId || conn.lastRunId || null,
+        summary: reason,
+    });
     void reason;
 }
 function noteSuccessfulRun(conn) {
@@ -622,6 +896,38 @@ function noteSuccessfulRun(conn) {
     conn.interruptionCooldownUntil = undefined;
     conn.runtimeState = 'idle_waiting';
 }
+function recordTraceRuntime(conn, flow) {
+    const tracePath = flow.postSendScreenshotPath || flow.screenshotPath;
+    if (flow.rpaRunId)
+        conn.lastRunId = flow.rpaRunId;
+    if (tracePath)
+        conn.lastTracePath = tracePath;
+    conn.lastTraceSummary = flow.rpaTraceSummary || [
+        flow.groupName ? `group=${flow.groupName}` : '',
+        flow.ok === false ? 'failed' : flow.interrupted ? 'interrupted' : 'ok',
+        flow.reason ? `reason=${flow.reason}` : '',
+    ].filter(Boolean).join(' ');
+}
+function addTaskSummary(conn, summary) {
+    const runId = summary.runId || conn.lastRunId || `local:${Date.now().toString(36)}`;
+    conn.lastRunId = runId;
+    conn.recentTaskSummaries.unshift({
+        at: new Date().toISOString(),
+        status: summary.status,
+        runId,
+        summary: clipSummary(summary.summary),
+    });
+    conn.recentTaskSummaries = conn.recentTaskSummaries.slice(0, MAX_RECENT_TASK_SUMMARIES);
+}
+function classifyWeChatRpaFailure(message) {
+    const value = String(message || '').toLowerCase();
+    return /permission|accessibility|screen recording|automation|window|foreground|target group|refusing|requires|安全|权限|窗口|目标群/.test(value)
+        ? 'blocked'
+        : 'failed';
+}
+function clipSummary(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, 180);
+}
 function isInterruptionCooldownActive(conn, secret) {
     if (secret.forceForeground)
         return false;
@@ -735,25 +1041,10 @@ function clampNumber(value, fallback, min, max) {
         return fallback;
     return Math.min(max, Math.max(min, number));
 }
-function normalizeCloudOcrMode(value) {
-    return value === 'fallback' || value === 'always' ? value : 'off';
-}
 function recordCloudOcrRuntime(conn, flow) {
-    if (!flow.cloudOcrPurpose && !flow.cloudOcrRequestId && !flow.cloudOcrUsage)
-        return;
-    conn.lastCloudOcrAt = new Date().toISOString();
-    conn.lastCloudOcrPurpose = flow.cloudOcrPurpose;
-    conn.lastCloudOcrRequestId = flow.cloudOcrRequestId;
-    conn.lastCloudOcrImageHash = flow.cloudOcrImageHash;
-    conn.lastCloudOcrUsage = normalizeCloudOcrUsage(flow.cloudOcrUsage);
-}
-function normalizeCloudOcrUsage(value) {
-    if (!value)
-        return undefined;
-    const usage = {
-        ...(Number.isFinite(value.inputTokens) ? { inputTokens: Number(value.inputTokens) } : {}),
-        ...(Number.isFinite(value.outputTokens) ? { outputTokens: Number(value.outputTokens) } : {}),
-        ...(Number.isFinite(value.totalTokens) ? { totalTokens: Number(value.totalTokens) } : {}),
-    };
-    return Object.keys(usage).length ? usage : undefined;
+    void conn;
+    void flow;
+    // WeChat RPA production routing is local OCR only. Legacy cloud OCR payload
+    // fields may still appear in old fixtures, but the channel must not publish
+    // them as runtime status or invite a server OCR dependency back in.
 }