evolcore 0.0.3 → 0.0.4

package/dist/channels/daemon.js

@@ -28,10 +28,13 @@ export class DaemonChannel {
         const pendingId = ctx.attemptId ?? runId;
         const messageId = pendingId;
         const startedAt = Date.now();
+        const remainingExecutionMs = ctx.executionDeadlineAt === undefined
+            ? this.totalExecutionMs
+            : Math.max(1, ctx.executionDeadlineAt - startedAt);
         const promise = new Promise((resolve) => {
             const watchdogTimer = setTimeout(() => this.watchdogTimeout(pendingId), this.watchdogMs);
             watchdogTimer.unref?.();
-            const totalExecutionTimer = setTimeout(() => this.totalExecutionTimeout(pendingId), this.totalExecutionMs);
+            const totalExecutionTimer = setTimeout(() => this.totalExecutionTimeout(pendingId, remainingExecutionMs), remainingExecutionMs);
             totalExecutionTimer.unref?.();
             this.pending.set(pendingId, {
                 resolve,
@@ -208,6 +211,17 @@ export class DaemonChannel {
             : `trigger:${trigger.id}`;
         return await this.sessionManager.getOrCreateSession(this.channelName, channelId, projectPath, threadId, { channelKey: this.channelKey, peerId: `trigger:${trigger.id}`, peerName: trigger.name }, trigger.name, undefined, 'private', baseagent, trigger.agentAid, this.channelName, 'system');
     }
+    executionDeadlineAt(startedAt = Date.now()) {
+        return startedAt + this.totalExecutionMs;
+    }
+    async getResumableConversationSession(sessionId) {
+        const session = await this.sessionManager.getSessionById(sessionId);
+        if (!session?.agentSessionId)
+            return undefined;
+        if (!this.sessionManager.checkSessionFileExists(session.projectPath, session.agentSessionId, session.baseagent))
+            return undefined;
+        return session;
+    }
     /** Internal Trigger audit hook. It does not emit user-visible output. */
     recordExecutionAnomaly(runId, value) {
         const slot = this.pending.get(runId);
@@ -330,17 +344,17 @@ export class DaemonChannel {
         slot.watchdogTimer = setTimeout(() => this.watchdogTimeout(runId), this.watchdogMs);
         slot.watchdogTimer.unref?.();
     }
-    totalExecutionTimeout(runId) {
+    totalExecutionTimeout(runId, totalExecutionMs = this.totalExecutionMs) {
         const slot = this.pending.get(runId);
         if (!slot || slot.terminalClaim)
             return;
         slot.acc.error = {
             reason: 'daemon_total_execution_timeout',
-            text: `daemon conversation exceeded total execution limit of ${this.totalExecutionMs}ms`,
+            text: `daemon conversation exceeded total execution limit of ${totalExecutionMs}ms`,
         };
         if (!this.claimTerminal(slot, 'timeout', {
             errorType: 'daemon_total_execution_timeout',
-            totalExecutionMs: this.totalExecutionMs,
+            totalExecutionMs,
         }))
             return;
         this.cancelDeliveryInBackground(slot);

package/dist/channels/dingtalk.js

@@ -1,14 +1,14 @@
 import fs from 'fs';
 import path from 'path';
-import { createHash, randomInt } from 'crypto';
+import { createHash } from 'crypto';
 import { logger } from '../utils/logger.js';
 import { requireOptional } from '../utils/npm-ops.js';
 import { middleOutputModePolicy, resolveShowActivities, showActivitiesPolicy } from '../core/channel-loader.js';
 import { formatItemsAsText } from '../core/message/items-formatter.js';
+import { createSendFileMarkerPattern } from '../core/message/file-markers.js';
 import { sentReceipt, suppressedReceipt } from '../core/message/send-receipt.js';
 import { initWelcomeManager, sendWelcomeIfNeeded } from '../utils/welcome.js';
-import { isValidAid } from '../aun/aid/validation.js';
-import { bindContactAlias } from '../config/contact-book.js';
+import { CONTACT_BIND_CODE_TTL_MS, CONTACT_BIND_MAX_FAILED_ATTEMPTS, ContactBindCodeRegistry, handleExplicitContactBindCommand, } from '../config/contact-bind-code.js';
 import { resolvePaths } from '../paths.js';
 const DINGTALK_QUEUED_EMOTION = 'Pin';
 const DINGTALK_THINKING_EMOTION = 'BusinessTrip';
@@ -125,129 +125,24 @@ export function parseDingtalkCardCallback(data) {
         values: params,
     };
 }
-export const DINGTALK_BIND_CODE_TTL_MS = 10 * 60 * 1000;
-export const DINGTALK_BIND_MAX_FAILED_ATTEMPTS = 5;
-const pendingContactBinds = new Map();
+export const DINGTALK_BIND_CODE_TTL_MS = CONTACT_BIND_CODE_TTL_MS;
+export const DINGTALK_BIND_MAX_FAILED_ATTEMPTS = CONTACT_BIND_MAX_FAILED_ATTEMPTS;
+const dingtalkContactBinds = new ContactBindCodeRegistry({
+    channelType: 'dingtalk',
+    displayName: '钉钉',
+    initCommand: 'ec init dingtalk',
+});
 export function registerPendingDingtalkContactBind(req) {
-    const selfAid = String(req.selfAid || '').trim();
-    const channelName = String(req.channelName || '').trim();
-    const primaryId = String(req.primaryId || '').trim();
-    const now = req.now ?? Date.now();
-    const code = req.code ? String(req.code).trim() : generateDingtalkBindCode();
-    if (!isValidAid(selfAid))
-        return { ok: false, error: `invalid selfAid: ${req.selfAid}` };
-    if (!channelName)
-        return { ok: false, error: 'missing channelName' };
-    if (!isValidAid(primaryId))
-        return { ok: false, error: `invalid primaryId: ${req.primaryId}` };
-    if (!/^\d{6}$/.test(code))
-        return { ok: false, error: 'binding code must be 6 digits' };
-    const key = pendingBindKey(selfAid, channelName);
-    const replaced = pendingContactBinds.has(key);
-    const item = {
-        selfAid,
-        channelName,
-        primaryId,
-        code,
-        createdAt: now,
-        expiresAt: now + DINGTALK_BIND_CODE_TTL_MS,
-        failedAttempts: 0,
-        maxFailedAttempts: DINGTALK_BIND_MAX_FAILED_ATTEMPTS,
-    };
-    pendingContactBinds.set(key, item);
-    return { ok: true, code, expiresAt: item.expiresAt, replaced };
+    return dingtalkContactBinds.register(req);
 }
 export function handlePendingDingtalkContactBindMessage(ctx) {
-    if (ctx.channelType !== 'dingtalk')
-        return { handled: false };
-    const selfAid = String(ctx.selfAid || '').trim();
-    const channelName = String(ctx.channelName || '').trim();
-    if (!selfAid || !channelName)
-        return { handled: false };
-    const key = pendingBindKey(selfAid, channelName);
-    const item = pendingContactBinds.get(key);
-    if (!item)
-        return { handled: false };
-    const now = ctx.now ?? Date.now();
-    if (now >= item.expiresAt) {
-        pendingContactBinds.delete(key);
-        return {
-            handled: true,
-            status: 'expired',
-            remainingAttempts: 0,
-            reply: '钉钉身份绑定码已超时，本次绑定失败。请重新执行 ec init dingtalk 并再次扫码绑定。',
-        };
-    }
-    if (ctx.chatType !== 'private')
-        return { handled: false };
-    const input = String(ctx.content ?? '').trim();
-    if (!/^\d+$/.test(input) || !/^\d{6}$/.test(input)) {
-        return {
-            handled: true,
-            status: 'format',
-            reply: '请直接发送 6 位数字绑定码。',
-            remainingAttempts: item.maxFailedAttempts - item.failedAttempts,
-        };
-    }
-    if (input !== item.code) {
-        item.failedAttempts += 1;
-        const remaining = Math.max(0, item.maxFailedAttempts - item.failedAttempts);
-        if (remaining === 0) {
-            pendingContactBinds.delete(key);
-            return {
-                handled: true,
-                status: 'failed',
-                remainingAttempts: 0,
-                reply: '绑定码无效，本次钉钉身份绑定失败。请重新执行 ec init dingtalk 并再次扫码绑定。',
-            };
-        }
-        return {
-            handled: true,
-            status: 'wrong-code',
-            remainingAttempts: remaining,
-            reply: '绑定码错误，请重新发送 6 位数字绑定码。',
-        };
-    }
-    const actorId = String(ctx.actorId || '').trim();
-    if (!actorId) {
-        return {
-            handled: true,
-            status: 'missing-actor',
-            remainingAttempts: item.maxFailedAttempts - item.failedAttempts,
-            reply: '无法识别当前钉钉发送者身份，未建立绑定。请重新发送绑定码或重新执行绑定流程。',
-        };
-    }
-    try {
-        bindContactAlias(item.selfAid, item.primaryId, 'dingtalk', actorId, item.channelName);
-        pendingContactBinds.delete(key);
-        return {
-            handled: true,
-            status: 'bound',
-            reply: `钉钉身份绑定成功：${item.channelName}:${encodeURIComponent(actorId)} -> ${item.primaryId}`,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            handled: true,
-            status: 'write-failed',
-            remainingAttempts: item.maxFailedAttempts - item.failedAttempts,
-            reply: `钉钉身份绑定写入失败：${message}`,
-        };
-    }
+    return handleExplicitContactBindCommand(dingtalkContactBinds, ctx);
 }
-export function getPendingDingtalkContactBind(selfAid, channelName) {
-    const item = pendingContactBinds.get(pendingBindKey(selfAid, channelName));
-    return item ? { ...item } : null;
+export function getPendingDingtalkContactBind(selfAid, channelName, primaryId) {
+    return dingtalkContactBinds.get(selfAid, channelName, primaryId);
 }
 export function clearPendingDingtalkContactBinds() {
-    pendingContactBinds.clear();
-}
-function generateDingtalkBindCode() {
-    return String(randomInt(0, 1_000_000)).padStart(6, '0');
-}
-function pendingBindKey(selfAid, channelName) {
-    return `${String(selfAid || '').trim()}\u0000${String(channelName || '').trim()}`;
+    dingtalkContactBinds.clear();
 }
 // ── Webhook SSRF validation ────────────────────────────────────────────────────
 const WEBHOOK_RE = /^https:\/\/(api|oapi)\.dingtalk\.com\//;
@@ -268,6 +163,9 @@ export class DingtalkChannel {
     queuedReactions = new Map();
     thinkingReactions = new Map();
     taskReactionMessages = new Map();
+    // A resumed task has no inbound event in this process. Retain the persisted
+    // chat route used to create its replacement and terminal reactions.
+    reactionConversationIds = new Map();
     seenMessages = new Map();
     interactionCallback;
     interactionInvalidationCallback;
@@ -813,16 +711,26 @@ export class DingtalkChannel {
         await this.ensureReaction(messageId, DINGTALK_QUEUED_EMOTION, this.queuedReactions);
     }
     /** Upgrade Queued to Thinking without leaving a visible state gap. */
-    async promoteAckReaction(messageId, taskId, sourceMessageIds) {
+    async promoteAckReaction(messageId, taskId, sourceMessageIds, restartResume = false, channelId) {
         const messageIds = [...new Set([...(sourceMessageIds ?? []), messageId].filter(Boolean))];
         if (taskId)
             this.taskReactionMessages.set(taskId, messageIds);
+        const fallbackConversationId = this.conversationIdFor(channelId);
+        if (fallbackConversationId) {
+            for (const id of messageIds)
+                this.reactionConversationIds.set(id, fallbackConversationId);
+        }
         // Register every in-flight reaction before yielding. A very short task may
         // otherwise finalize while later messages in a merged batch are still
         // untracked, leaving a late BusinessTrip behind.
-        const thinking = messageIds.map(id => (this.ensureReaction(id, DINGTALK_THINKING_EMOTION, this.thinkingReactions)));
+        const thinking = messageIds.map(id => (this.ensureReaction(id, DINGTALK_THINKING_EMOTION, this.thinkingReactions, fallbackConversationId)));
         await Promise.all(thinking);
-        await Promise.all(messageIds.map(id => (this.clearReaction(id, DINGTALK_QUEUED_EMOTION, this.queuedReactions))));
+        if (restartResume) {
+            // Daemon shutdown finalized the old task as Wrong. DingTalk can recall a
+            // built-in reaction by name, so no process-local reaction ID is needed.
+            await Promise.all(messageIds.map(id => (this.sendEmotion(id, DINGTALK_WRONG_EMOTION, true, fallbackConversationId))));
+        }
+        await Promise.all(messageIds.map(id => (this.clearReaction(id, DINGTALK_QUEUED_EMOTION, this.queuedReactions, fallbackConversationId))));
     }
     /** Clear processing reactions and replace them with Done or Wrong. */
     async completeAckReaction(taskId, completed) {
@@ -831,24 +739,31 @@ export class DingtalkChannel {
             return;
         this.taskReactionMessages.delete(taskId);
         for (const messageId of messageIds) {
+            const fallbackConversationId = this.reactionConversationIds.get(messageId);
             // Add the terminal state first so users never see an empty reaction gap.
-            let terminalAdded = await this.sendEmotion(messageId, completed ? DINGTALK_DONE_EMOTION : DINGTALK_WRONG_EMOTION, false);
+            let terminalAdded = await this.sendEmotion(messageId, completed ? DINGTALK_DONE_EMOTION : DINGTALK_WRONG_EMOTION, false, fallbackConversationId);
             if (!terminalAdded) {
-                terminalAdded = await this.sendEmotion(messageId, completed ? DINGTALK_DONE_EMOTION : DINGTALK_WRONG_EMOTION, false);
+                terminalAdded = await this.sendEmotion(messageId, completed ? DINGTALK_DONE_EMOTION : DINGTALK_WRONG_EMOTION, false, fallbackConversationId);
             }
             if (!terminalAdded) {
                 logger.warn(`[DingTalk] Failed to add terminal reaction for ${messageId}; preserving processing reaction`);
                 continue;
             }
-            await this.clearReaction(messageId, DINGTALK_QUEUED_EMOTION, this.queuedReactions);
-            await this.clearReaction(messageId, DINGTALK_THINKING_EMOTION, this.thinkingReactions);
+            await this.clearReaction(messageId, DINGTALK_QUEUED_EMOTION, this.queuedReactions, fallbackConversationId);
+            await this.clearReaction(messageId, DINGTALK_THINKING_EMOTION, this.thinkingReactions, fallbackConversationId);
+            this.reactionConversationIds.delete(messageId);
         }
     }
-    async ensureReaction(messageId, emotionName, reactions) {
+    conversationIdFor(channelId) {
+        if (!channelId)
+            return undefined;
+        return this.routes.get(channelId)?.conversationId ?? this.conversationIdCache.get(channelId);
+    }
+    async ensureReaction(messageId, emotionName, reactions, fallbackConversationId) {
         const existing = reactions.get(messageId);
         if (existing)
             return existing;
-        const pending = this.sendEmotion(messageId, emotionName, false)
+        const pending = this.sendEmotion(messageId, emotionName, false, fallbackConversationId)
             .then((ok) => {
             if (!ok)
                 reactions.delete(messageId);
@@ -861,18 +776,18 @@ export class DingtalkChannel {
         reactions.set(messageId, pending);
         return pending;
     }
-    async clearReaction(messageId, emotionName, reactions) {
+    async clearReaction(messageId, emotionName, reactions, fallbackConversationId) {
         const pending = reactions.get(messageId);
         if (!pending)
             return;
         const added = await pending.catch(() => false);
         if (added)
-            await this.sendEmotion(messageId, emotionName, true);
+            await this.sendEmotion(messageId, emotionName, true, fallbackConversationId);
         reactions.delete(messageId);
     }
-    async sendEmotion(messageId, emotionName, recall) {
-        const context = this.messageContextCache.get(messageId);
-        if (!context) {
+    async sendEmotion(messageId, emotionName, recall, fallbackConversationId) {
+        const openConversationId = this.messageContextCache.get(messageId)?.openConversationId ?? fallbackConversationId;
+        if (!openConversationId) {
             logger.debug(`[DingTalk] Cannot ${recall ? 'recall' : 'add'} emotion: no context for message ${messageId}`);
             return false;
         }
@@ -891,7 +806,7 @@ export class DingtalkChannel {
                 body: JSON.stringify({
                     robotCode: this.config.clientId,
                     openMsgId: messageId,
-                    openConversationId: context.openConversationId,
+                    openConversationId,
                     // Pin / BusinessTrip / Done / Wrong are DingTalk built-in
                     // reactions. emotionType=2 is for custom text reactions and
                     // causes BusinessTrip to fail with system.error.
@@ -1438,7 +1353,7 @@ export class DingtalkChannelPlugin {
                 }
             },
             acknowledge: (messageId) => channel.acknowledgeMessage(messageId),
-            promoteAck: (messageId, context) => (channel.promoteAckReaction(messageId, context?.taskId, context?.messageIds)),
+            promoteAck: (messageId, context) => (channel.promoteAckReaction(messageId, context?.taskId, context?.messageIds, context?.restartResume, context?.channelId)),
             onInteraction: (callback) => channel.onInteraction(callback),
             onInteractionInvalidated: (callback) => channel.onInteractionInvalidated(callback),
             invalidateInteraction: (interactionId, reason) => channel.invalidateInteraction(interactionId, reason),
@@ -1458,7 +1373,7 @@ export class DingtalkChannelPlugin {
         return {
             channelType: 'dingtalk', adapter, channel,
             policy,
-            options: { fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g, supportsImages: true, flushDelay: inst.flushDelay },
+            options: { fileMarkerPattern: createSendFileMarkerPattern(), supportsImages: true, flushDelay: inst.flushDelay },
             connect: () => channel.connect(),
             disconnect: () => channel.disconnect(),
             onProjectPathRequest: () => Promise.resolve(ctx.defaultProjectPath),

package/dist/channels/feishu.js

@@ -4,9 +4,28 @@ import imageType from 'image-type';
 import { sanitizeFileName, saveToUploads, bufferToInboundImage } from '../utils/media-cache.js';
 import { logger } from '../utils/logger.js';
 import { formatItemsAsText } from '../core/message/items-formatter.js';
+import { createSendFileMarkerPattern } from '../core/message/file-markers.js';
 import { initWelcomeManager, sendWelcomeIfNeeded } from '../utils/welcome.js';
 import { chatDirPath, decodeDirSegment } from '../core/session/session-fs-store.js';
 import { sentReceipt, suppressedReceipt } from '../core/message/send-receipt.js';
+import { ContactBindCodeRegistry, handleExplicitContactBindCommand, } from '../config/contact-bind-code.js';
+const feishuContactBinds = new ContactBindCodeRegistry({
+    channelType: 'feishu',
+    displayName: '飞书',
+    initCommand: 'ec init feishu',
+});
+export function registerPendingFeishuContactBind(req) {
+    return feishuContactBinds.register(req);
+}
+export function handlePendingFeishuContactBindMessage(ctx) {
+    return handleExplicitContactBindCommand(feishuContactBinds, ctx);
+}
+export function getPendingFeishuContactBind(selfAid, channelName, primaryId) {
+    return feishuContactBinds.get(selfAid, channelName, primaryId);
+}
+export function clearPendingFeishuContactBinds() {
+    feishuContactBinds.clear();
+}
 export class FeishuChannel {
     config;
     agentAid;
@@ -1307,7 +1326,7 @@ export class FeishuChannel {
         this.pinReactions.set(messageId, p);
     }
     /** Runner 开始执行时：添加 StatusInFlight，然后移除 Pin（视觉无闪烁） */
-    async promoteAckReaction(messageId, taskId, sourceMessageIds) {
+    async promoteAckReaction(messageId, taskId, sourceMessageIds, restartResume = false) {
         const messageIds = [...new Set([...(sourceMessageIds ?? []), messageId].filter(Boolean))];
         if (taskId)
             this.taskAckMessages.set(taskId, messageIds);
@@ -1328,6 +1347,8 @@ export class FeishuChannel {
         // Every in-flight reaction is registered before this first await, so a
         // fast terminal event cannot race ahead and strand a merged-batch status.
         for (const { id, pending } of promotions) {
+            if (restartResume)
+                await this.clearRestartCrossMark(id);
             const reactionId = await pending;
             if (reactionId) {
                 await this.client.im.messageReaction.delete({
@@ -1336,6 +1357,31 @@ export class FeishuChannel {
             }
         }
     }
+    /**
+     * A daemon restart terminates the old task with CrossMark. The reaction IDs
+     * are process-local, so a resumed process must discover and remove its own
+     * stale terminal reaction before it can show the new task state.
+     */
+    async clearRestartCrossMark(messageId) {
+        const reactions = this.client?.im?.messageReaction;
+        if (!reactions?.list || !reactions?.delete)
+            return;
+        try {
+            const response = await reactions.list({
+                path: { message_id: messageId },
+                params: { reaction_type: 'CrossMark', page_size: 50 },
+            });
+            const staleReactionIds = (response?.data?.items ?? [])
+                .filter((reaction) => (reaction?.reaction_type?.emoji_type === 'CrossMark'
+                && reaction?.operator?.operator_type === 'app'
+                && typeof reaction?.reaction_id === 'string'))
+                .map((reaction) => reaction.reaction_id);
+            await Promise.all(staleReactionIds.map(reactionId => (reactions.delete({ path: { message_id: messageId, reaction_id: reactionId } }).catch(() => { }))));
+        }
+        catch {
+            // A missing reaction-list permission must not block the resumed task.
+        }
+    }
     /** 任务终态：用 CheckMark/CrossMark 替换 StatusInFlight。 */
     async finalizeAckReaction(taskId, terminalEmoji) {
         const messageIds = this.taskAckMessages.get(taskId);
@@ -1820,7 +1866,7 @@ export class FeishuChannelPlugin {
                 }
             },
             acknowledge: (messageId) => { channel.addPinReaction(messageId); return Promise.resolve(); },
-            promoteAck: (messageId, context) => (channel.promoteAckReaction(messageId, context?.taskId, context?.messageIds)),
+            promoteAck: (messageId, context) => (channel.promoteAckReaction(messageId, context?.taskId, context?.messageIds, context?.restartResume)),
             onInteraction: (callback) => channel.onInteraction(callback),
             onInteractionInvalidated: (callback) => channel.onInteractionInvalidated(callback),
             invalidateInteraction: (interactionId, reason) => channel.invalidateInteraction(interactionId, reason),
@@ -1840,17 +1886,23 @@ export class FeishuChannelPlugin {
         return {
             channelType: 'feishu', adapter, channel,
             policy,
-            options: { fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g, supportsImages: true, flushDelay: inst.flushDelay },
+            options: { fileMarkerPattern: createSendFileMarkerPattern(), supportsImages: true, flushDelay: inst.flushDelay },
             connect: () => channel.connect(),
             disconnect: () => channel.disconnect(),
             onProjectPathRequest: () => Promise.resolve(ctx.defaultProjectPath),
             registerBridge(bridge, channelType) {
                 bridge.register(adapter.channelName, (handler) => channel.onMessage(async ({ channelId: chatId, content, images, peerId, peerName, messageId, mentions, mentionAids, threadId, rootId, chatType, source }) => {
+                    const replyContext = peerId || threadId
+                        ? {
+                            ...(peerId ? { peerId } : {}),
+                            ...(threadId ? { threadId, replyToMessageId: rootId ?? threadId, replyInThread: true } : {}),
+                        }
+                        : undefined;
                     await handler({
                         channel: adapter.channelName, channelType, channelId: chatId, content, images,
                         selfAID: ctx.agentName, chatType: chatType || 'private',
                         peerId: peerId || '', peerName, messageId, mentions, mentionAids, threadId,
-                        replyContext: threadId ? { threadId, replyToMessageId: rootId ?? threadId, replyInThread: true } : undefined,
+                        replyContext,
                         source,
                     });
                 }), async (channelId, text, replyContext) => {

package/dist/channels/qqbot.js

@@ -3,7 +3,26 @@ import { markdownToPlainText } from '../utils/markdown-to-plain-text.js';
 import { requireOptional } from '../utils/npm-ops.js';
 import { middleOutputModePolicy, resolveShowActivities, showActivitiesPolicy } from '../core/channel-loader.js';
 import { formatItemsAsText } from '../core/message/items-formatter.js';
+import { createSendFileMarkerPattern } from '../core/message/file-markers.js';
 import { initWelcomeManager, sendWelcomeIfNeeded } from '../utils/welcome.js';
+import { ContactBindCodeRegistry, handleExplicitContactBindCommand, } from '../config/contact-bind-code.js';
+const qqbotContactBinds = new ContactBindCodeRegistry({
+    channelType: 'qqbot',
+    displayName: 'QQ',
+    initCommand: 'ec init qqbot',
+});
+export function registerPendingQQBotContactBind(req) {
+    return qqbotContactBinds.register(req);
+}
+export function handlePendingQQBotContactBindMessage(ctx) {
+    return handleExplicitContactBindCommand(qqbotContactBinds, ctx);
+}
+export function getPendingQQBotContactBind(selfAid, channelName, primaryId) {
+    return qqbotContactBinds.get(selfAid, channelName, primaryId);
+}
+export function clearPendingQQBotContactBinds() {
+    qqbotContactBinds.clear();
+}
 // ── QQBotChannel ────────────────────────────────────────────────────────────
 export class QQBotChannel {
     agentAid;
@@ -93,6 +112,9 @@ export class QQBotChannel {
         }
         logger.info('[QQBot] Disconnected');
     }
+    getStatus() {
+        return { connected: this.connected };
+    }
     onMessage(handler) {
         this.messageHandler = handler;
     }
@@ -390,7 +412,7 @@ export class QQBotChannelPlugin {
         return {
             channelType: 'qqbot', adapter, channel,
             policy,
-            options: { fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g, supportsImages: true, flushDelay: inst.flushDelay },
+            options: { fileMarkerPattern: createSendFileMarkerPattern(), supportsImages: true, flushDelay: inst.flushDelay },
             connect: () => channel.connect(),
             disconnect: () => channel.disconnect(),
             onProjectPathRequest: () => Promise.resolve(ctx.defaultProjectPath),