dsh-ant 0.6.1 → 0.6.3

package/delegation.js

@@ -5,14 +5,25 @@ import { dirname, join, resolve } from 'node:path'
 import { spawn } from 'node:child_process'
 import { CONVERSATION_TOOL_NAMES, TASK_DRAFT_TTL_MS, cancelSession, conversationKey,
   buildTaskContext, cardReviewers, createConversationEngine, giteaPullRequestContext, isHelpRequest,
-  modelFor, requestsPrivateReply, teamModelProvider, truncateTaskOutput,
-  promptAndCollectSessionTurn, taskErrorText } from './conversation.js'
+  modelFor, prompt, requestsPrivateReply, restrictedSession, teamModelProvider, truncateTaskOutput,
+  promptAndCollectSessionTurn, taskErrorText, waitForSignal } from './conversation.js'
 
 const MAX_DIFF_BYTES = 240_000
 const MAX_GITEA_JSON_BYTES = 64_000
 const MAX_REPLY_LENGTH = 3_800
 const LEDGER_EVENT_TTL_MS = 30 * 86_400_000
 const MAX_LEDGER_EVENTS = 1_000
+const OWNER_APPROVAL_TTL_MS = 90 * 86_400_000
+const MAX_OWNER_APPROVAL_ENTRIES = 1_000
+const OWNER_APPROVAL_COMPACT_STATUSES = new Set([
+  'done', 'failed', 'canceled', 'rejected', 'expired', 'completed',
+])
+const OWNER_APPROVAL_TERMINAL_STATUSES = new Set(['done', 'failed', 'canceled', 'rejected', 'expired'])
+const OWNER_APPROVAL_RETAINED_FIELDS = new Set([
+  'key', 'kind', 'status', 'outcome', 'approval_id', 'request_sha256', 'task_id',
+  'service_url', 'scope', 'actor_id', 'conversation_kind', 'conversation_id',
+  'botId', 'fingerprint', 'route', 'created_at', 'failure_reason', 'finish_error',
+])
 const TASK_PRESET = 'ant-delegated-task'
 const MODEL_TIMEOUT_MS = 180_000
 const REVIEW_EXECUTORS = new Set(['dsh', 'codex', 'claude-code'])
@@ -161,6 +172,13 @@ export async function writeLocalDelegationSettings(patch, settingsPath = LOCAL_S
 function pruneLedgerEntries(entries, now) {
   const next = new Map(entries)
   for (const [key, saved] of next) {
+    if (saved.kind === 'owner_approval' && OWNER_APPROVAL_COMPACT_STATUSES.has(saved.status)) {
+      next.set(key, compactOwnerApproval(saved))
+      if (!OWNER_APPROVAL_TERMINAL_STATUSES.has(saved.status)) continue
+      const age = now - Date.parse(saved.created_at)
+      if (Number.isFinite(age) && age > OWNER_APPROVAL_TTL_MS) next.delete(key)
+      continue
+    }
     if (!['conversation_input', 'conversation_ignored', 'group_notice', 'chat_reply',
       'card_draft', 'card_task', 'legacy_pr_task'].includes(saved.kind)) continue
     const age = now - Date.parse(saved.created_at)
@@ -172,6 +190,10 @@ function pruneLedgerEntries(entries, now) {
       next.delete(key)
     }
   }
+  const ownerApprovals = [...next.values()].filter((saved) => saved.kind === 'owner_approval'
+    && OWNER_APPROVAL_TERMINAL_STATUSES.has(saved.status))
+    .sort((a, b) => (b.created_at || '').localeCompare(a.created_at || ''))
+  for (const saved of ownerApprovals.slice(MAX_OWNER_APPROVAL_ENTRIES)) next.delete(saved.key)
   const recentChats = [...next.values()].filter((saved) => saved.kind === 'chat_reply'
     && saved.status === 'done').sort((a, b) => (b.created_at || '').localeCompare(a.created_at || ''))
   for (const saved of recentChats.slice(1_000)) next.delete(saved.key)
@@ -189,6 +211,14 @@ function pruneLedgerEntries(entries, now) {
   return next
 }
 
+function compactOwnerApproval(entry) {
+  const retainedFields = entry.status === 'done' ? OWNER_APPROVAL_RETAINED_FIELDS
+    : new Set([...OWNER_APPROVAL_RETAINED_FIELDS, 'reply'])
+  const compact = Object.fromEntries(Object.entries(entry)
+    .filter(([key]) => retainedFields.has(key)))
+  return Object.keys(compact).length === Object.keys(entry).length ? entry : compact
+}
+
 export class DelegationLedger {
   constructor(path = join(dshRoot(), 'ant-delegation', 'events.json')) {
     this.path = path
@@ -223,7 +253,8 @@ export class DelegationLedger {
       }
     }
     const next = pruneLedgerEntries(loaded, Date.now())
-    if (next.size !== loaded.size) changed = true
+    if (next.size !== loaded.size
+      || [...next.entries()].some(([key, entry]) => loaded.get(key) !== entry)) changed = true
     if (changed) await this.writeSnapshot(next)
     else this.entries = next
     return this
@@ -274,7 +305,8 @@ function statusErrorText(value) {
 export async function recentDelegationStatus(serviceUrl, limit = 12) {
   const ledger = await new DelegationLedger().load()
   return ledger.values().filter((entry) => entry.service_url === serviceUrl && entry.status !== 'ignored'
-    && (!entry.kind || ['card_task', 'legacy_pr_task'].includes(entry.kind)))
+    && (!entry.kind || ['card_task', 'legacy_pr_task', 'owner_approval'].includes(entry.kind))
+    && (entry.kind !== 'owner_approval' || typeof entry.task_id === 'string'))
     .sort((left, right) => (right.created_at || '').localeCompare(left.created_at || ''))
     .slice(0, limit)
     .map((entry) => ({
@@ -284,9 +316,9 @@ export async function recentDelegationStatus(serviceUrl, limit = 12) {
       repository: entry.grant?.repository || null,
       pr_number: entry.grant?.pr_number || null,
       task_id: entry.task_id || null,
-      title: entry.card?.title || null,
-      outcome: entry.outcome || null,
-      failure_reason: statusErrorText(entry.failure_reason)
+      title: entry.card?.title || entry.proposal?.title || null,
+      outcome: entry.status === 'finishing' ? null : entry.outcome || null,
+      failure_reason: statusErrorText(entry.finish_error) || statusErrorText(entry.failure_reason)
         || (entry.outcome === 'failed' ? statusErrorText(entry.reply) : null),
       delivery_error: statusErrorText(entry.delivery_error),
     }))
@@ -994,7 +1026,19 @@ export async function runDshSubagentTask(ctx, executor, task, resources = [], se
   const boundedSignal = signal ? AbortSignal.any([signal, timeout]) : timeout
   let removeAbort = () => {}
   try {
-    const created = await ctx.sessionController.create({ cwd: workspace, agentPreset: TASK_PRESET })
+    const createPromise = Promise.resolve().then(() => {
+      boundedSignal.throwIfAborted()
+      return ctx.sessionController.create({ cwd: workspace, agentPreset: TASK_PRESET })
+    })
+    let created
+    try { created = await waitForSignal(createPromise, boundedSignal) }
+    catch (error) {
+      if (boundedSignal.aborted) {
+        void createPromise.then((lateSession) => cancelSession(ctx, lateSession.sessionId))
+          .catch((cleanupError) => logger.warn?.('ANT 迟到的任务会话清理失败:', cleanupError?.message))
+      }
+      throw error
+    }
     sessionId = created.sessionId
     if (created.agentPreset !== TASK_PRESET || typeof sessionId !== 'string' || !sessionId) {
       throw new Error('DSH 未启用 ANT 受限任务父会话。')
@@ -1253,6 +1297,11 @@ export function taskGate(initialLimit = 3) {
   }
 }
 
+// A card task can span several messages; the owner must see the text the executor will receive.
+export function ownerApprovalRequestText(messageText, cardTask) {
+  return (cardTask?.authorization?.request_text || messageText).slice(0, 8_192)
+}
+
 export function startDelegationHost(ctx, readConnection, { ledger = new DelegationLedger(), logger = console,
   workspaceRoot = dshRoot(), readSettings = readLocalDelegationSettings } = {}) {
   const controller = new AbortController()
@@ -1268,9 +1317,11 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
   const processing = new Set()
   const processingTasks = new Set()
   const legacyTaskControllers = new Map()
+  const ownerApprovalTaskControllers = new Map()
   const receiptPending = new Set()
   const accepting = new Map()
   const sessionIds = new Set()
+  const pendingOwnerChallenges = new Map()
   const gate = taskGate()
   let refreshing = false
   let refreshDone = Promise.resolve()
@@ -1286,7 +1337,8 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
     const event = turn.event
     const title = typeof args?.title === 'string' ? args.title.trim().slice(0, 100) : ''
     const taskPrompt = typeof args?.task_prompt === 'string' ? args.task_prompt.trim().slice(0, 4_000) : ''
-    const requestText = addressedText(event).slice(0, 8_192)
+    const cardTask = args?.card_task || null
+    const requestText = ownerApprovalRequestText(addressedText(event), cardTask)
     if (!title || !taskPrompt || !requestText) throw new Error('本次审批请求缺少标题、执行说明或原始请求。')
     if (turn.owner_approval_bound !== true) {
       throw new Error('机器人主人尚未绑定审批私聊，请联系 B 在 ANT 协作设置中绑定。')
@@ -1303,14 +1355,16 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
       requester_id: event.actor.id, message_id: event.messageId,
       conversation_kind: event.conversation.kind,
       ...(event.conversation.kind === 'group' ? { conversation_id: event.conversation.id } : {}),
-      request_text: requestText, title, task_prompt: taskPrompt }
+      request_text: requestText, title, task_prompt: taskPrompt,
+      ...(cardTask ? { card_id: cardTask.card.id, parameters: cardTask.parameters } : {}) }
     const requestHash = createHash('sha256').update(JSON.stringify(bound)).digest('hex')
     const approval = await memberJson(turn.connection, '/api/me/im-delegations/owner-approvals', {
       method: 'POST', body: JSON.stringify({ bot_id: event.botId,
         bot_fingerprint: event.fingerprint, requester_id: event.actor.id,
         message_id: event.messageId, conversation_kind: event.conversation.kind,
         ...(event.conversation.kind === 'group' ? { conversation_id: event.conversation.id } : {}),
-        request_sha256: requestHash }), signal: requestSignal,
+        request_sha256: requestHash, ...(cardTask ? { card_id: cardTask.card.id } : {}) }),
+      signal: requestSignal,
     })
     if (!/^[A-F0-9]{12}$/u.test(approval.id || '') || !approval.target_id
       || !approval.owner_sender_id || !Number.isSafeInteger(approval.expires_at)) {
@@ -1323,13 +1377,17 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
       ...(event.conversation.kind === 'group' ? { conversation_id: event.conversation.id } : {}),
       service_url: turn.connection.serviceUrl, route: event.reply, scope: turn.scope,
       target_id: approval.target_id, owner_sender_id: approval.owner_sender_id,
-      created_at: event.at, expires_at: approval.expires_at, status: 'pending' })
+      created_at: event.at, expires_at: approval.expires_at, status: 'pending',
+      ...(cardTask ? { card_task: cardTask } : {}) })
     const available = []
-    if (ctx.sessionController && ctx.agents) available.push('dsh')
-    try {
-      const providers = (ctx.get?.('subagents') ?? ctx.subagents)?.list?.() || []
-      for (const runner of ['codex', 'claude-code']) if (providers.includes(runner)) available.push(runner)
-    } catch {}
+    if (cardTask) available.push(cardTask.card.runner)
+    else {
+      if (ctx.sessionController && ctx.agents) available.push('dsh')
+      try {
+        const providers = (ctx.get?.('subagents') ?? ctx.subagents)?.list?.() || []
+        for (const runner of ['codex', 'claude-code']) if (providers.includes(runner)) available.push(runner)
+      } catch {}
+    }
     if (!available.length) {
       await memberJson(turn.connection, `/api/me/im-delegations/owner-approvals/${approval.id}/cancel`,
         { method: 'POST', body: '{}', signal: requestSignal })
@@ -1346,7 +1404,9 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
       `A 的原始请求：${requestText}`,
       `拟执行任务：${title}`,
       `执行说明：${taskPrompt}`,
-      `可选执行器：${available.join('、')}`,
+      ...(cardTask ? [`任务参数：${JSON.stringify(cardTask.parameters)}`,
+        `任务卡执行器：${(cardTask.parallel_agents || cardTask.card.cross_review_always
+          ? cardTask.card.reviewers : available).join('、')}`] : [`可选执行器：${available.join('、')}`]),
       '权限说明：DSH 仅使用团队模型；Codex/Claude Code 按本机 DSH Provider Profile 的文件、Git、网络权限运行，ANT 不会把这些权限隔离到本次任务。结果返回原会话。批准前不会启动。',
       ...available.map((runner) => `批准：批准 ${approval.id} ${runner}`),
       `拒绝：拒绝 ${approval.id}`,
@@ -1384,7 +1444,7 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
   async function runApprovedDshTask(entry, connection, taskSignal) {
     const model = await modelFor(ctx, memberJson, connection)
     const { sessionId, cwd } = await restrictedSession(ctx, model, workspaceRoot,
-      sessionIds, null, null, TASK_PRESET)
+      sessionIds, null, null, TASK_PRESET, taskSignal)
     try {
       const text = [
         '这是一项由机器人主人 B 明确批准、只执行一次的任务。只按 B 已确认的执行说明处理，不扩大任务范围。',
@@ -1402,14 +1462,19 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
     }
   }
 
-  async function executeOwnerApproval(entry, acceptedConnection, signal) {
+  async function executeOwnerApproval(entry, acceptedConnection) {
     if (processing.has(entry.key)) return
     processing.add(entry.key)
+    const runningTask = { controller: new AbortController(), finished: false }
+    const taskSignal = AbortSignal.any([controller.signal, runningTask.controller.signal])
+    ownerApprovalTaskControllers.set(entry.key, runningTask)
     let release = null
     let outcome = 'failed'
     let resultText = '任务未完成，请重新发起审批请求。'
+    let interruptedForRestart = false
     try {
-      release = await gate.acquire(signal)
+      release = await gate.acquire(taskSignal)
+      entry = await ledger.put({ ...entry, status: 'running' })
       const connection = await readConnection()
       if (!connection || connection.serviceUrl !== acceptedConnection.serviceUrl
         || connection.serviceUrl !== entry.service_url) throw new Error('ANT 团队连接已变化，任务没有启动。')
@@ -1420,28 +1485,43 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
         for (const runner of ['codex', 'claude-code']) if (providers.includes(runner)) available.push(runner)
       } catch {}
       if (!available.includes(entry.runner)) throw new Error(`这台 DSH 当前没有启用 ${entry.runner} 执行器。`)
-      signal.throwIfAborted()
+      taskSignal.throwIfAborted()
       const task = { title: entry.proposal.title, task_prompt: entry.proposal.task_prompt,
-        request_text: entry.request_text, owner_approval_id: entry.approval_id }
+        request_text: entry.request_text, owner_approval_id: entry.approval_id, task_id: entry.task_id }
       const result = entry.runner === 'dsh'
-        ? await runApprovedDshTask(entry, connection, signal)
+        ? await runApprovedDshTask(entry, connection, taskSignal)
         : await runDshSubagentTask(ctx, entry.runner, task, [], sessionIds,
-          signal, workspaceRoot, logger)
-      signal.throwIfAborted()
+          taskSignal, workspaceRoot, logger)
+      taskSignal.throwIfAborted()
+      runningTask.finished = true
       outcome = 'completed'
       resultText = `${entry.proposal.title}已完成：\n${truncateTaskOutput(result, MAX_REPLY_LENGTH - entry.proposal.title.length - 20)}`
     } catch (error) {
-      outcome = signal.aborted ? 'canceled' : 'failed'
-      resultText = outcome === 'canceled' ? '主人审批的任务已取消，未自动重试。'
-        : `主人审批的任务未完成：${taskErrorText(error, '请检查本机执行器状态后重新发起。')}`
+      runningTask.finished = true
+      if (controller.signal.aborted && !runningTask.controller.signal.aborted) {
+        interruptedForRestart = true
+      } else {
+        outcome = runningTask.controller.signal.aborted ? 'canceled' : 'failed'
+        if (outcome === 'canceled') resultText = '主人审批的任务已取消，未自动重试。'
+        else {
+          entry = { ...entry, failure_reason: taskErrorText(error, '请检查本机执行器状态后重新发起。') }
+          resultText = `主人审批的任务未完成：${entry.failure_reason}`
+        }
+      }
     } finally {
       release?.()
     }
+    if (interruptedForRestart) {
+      ownerApprovalTaskControllers.delete(entry.key)
+      processing.delete(entry.key)
+      return
+    }
     try {
+      entry = await ledger.put({ ...entry, status: 'finishing', outcome, reply: resultText })
       const currentConnection = await readConnection()
       if (!currentConnection || currentConnection.serviceUrl !== entry.service_url) {
-        await ledger.put({ ...entry, status: outcome, outcome,
-          failure_reason: 'ANT 团队连接已变化，任务结果没有发送。' })
+        await ledger.put({ ...entry, status: 'finishing', outcome,
+          finish_error: 'ANT 团队连接已变化，服务端终态和任务结果待核对。' })
         return
       }
       const finished = await memberJson(currentConnection,
@@ -1449,34 +1529,63 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
           method: 'POST', body: JSON.stringify({ outcome }), signal: controller.signal,
         })
       if (finished?.finished !== true) {
-        await ledger.put({ ...entry, status: outcome, outcome,
-          failure_reason: '服务端未确认审批任务仍有效；结果没有发送。' })
+        await ledger.put({ ...entry, status: 'finishing', outcome,
+          finish_error: '服务端未确认审批任务终态；请检查主人绑定和私聊权限后重试。' })
         return
       }
-      const final = await ledger.put({ ...entry, status: outcome, outcome, reply: resultText })
+      const final = await ledger.put({ ...entry, status: outcome, outcome, reply: resultText,
+        finish_error: null })
       await replyOwnerApprovalResult(final, resultText, currentConnection)
     } catch (error) {
       logger.warn?.('ANT 主人审批任务状态无法回写:', error?.message)
-      await ledger.put({ ...entry, status: 'failed', outcome: 'failed',
-        failure_reason: '服务端未确认任务终态；结果没有发送。' })
+      await ledger.put({ ...entry, status: 'finishing', outcome,
+        finish_error: statusErrorText(error?.message) || '服务端未确认审批任务终态；结果待核对。' })
     } finally {
+      ownerApprovalTaskControllers.delete(entry.key)
       processing.delete(entry.key)
     }
   }
 
+  // The approval is spent once the card task is queued; the card pipeline owns the task from there.
+  async function startApprovedCardTask(entry, connection) {
+    const finished = await memberJson(connection,
+      `/api/me/im-delegations/owner-approvals/${entry.approval_id}/finish`, {
+        method: 'POST', body: JSON.stringify({ outcome: 'completed' }), signal: controller.signal,
+      })
+    if (finished?.finished !== true) throw new Error('服务端未确认审批状态。')
+    await conversation.enqueueApprovedCardTask(entry)
+    await ledger.put({ ...entry, status: 'done', outcome: 'completed' })
+  }
+
   async function recoverOwnerApproval(entry, connection) {
     try {
       let state = await memberJson(connection,
         `/api/me/im-delegations/owner-approvals/${entry.approval_id}`)
+      if (entry.card_task && ['claimed', 'completed'].includes(state.status)) {
+        if (state.status === 'claimed') return await startApprovedCardTask(entry, connection)
+        await conversation.enqueueApprovedCardTask(entry)
+        await ledger.put({ ...entry, status: 'done', outcome: 'completed' })
+        return
+      }
       const wasClaimed = state.status === 'claimed'
       if (state.status === 'claimed') {
+        const finishOutcome = ['completed', 'failed', 'canceled'].includes(entry.outcome)
+          ? entry.outcome : 'failed'
         const finished = await memberJson(connection,
           `/api/me/im-delegations/owner-approvals/${entry.approval_id}/finish`, {
-            method: 'POST', body: JSON.stringify({ outcome: 'failed' }),
+            method: 'POST', body: JSON.stringify({ outcome: finishOutcome }),
           })
-        if (finished?.finished) state = { status: 'failed', outcome: 'failed', runner: state.runner }
-        else state = await memberJson(connection,
-          `/api/me/im-delegations/owner-approvals/${entry.approval_id}`)
+        if (finished?.finished) state = { status: finishOutcome, outcome: finishOutcome, runner: state.runner }
+        else {
+          state = await memberJson(connection,
+            `/api/me/im-delegations/owner-approvals/${entry.approval_id}`)
+          if (state.status === 'claimed') {
+            await ledger.put({ ...entry, status: 'finishing',
+              finish_error: entry.finish_error
+                || '服务端未确认审批任务终态；请检查主人绑定和私聊权限后重试。' })
+            return
+          }
+        }
       }
       if (['pending', 'approved'].includes(state.status)) return
       if (['reply_pending', 'done'].includes(entry.status)) return
@@ -1484,6 +1593,7 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
       if (state.status === 'expired') text = '主人审批已过期，任务没有启动。请重新发起请求。'
       else if (state.status === 'rejected') text = '主人拒绝了这次任务请求。'
       else if (state.status === 'canceled') text = '这次审批任务已取消，没有自动重试。'
+      else if (state.status === 'failed' && entry.reply) text = entry.reply
       else if (wasClaimed && state.status === 'failed') {
         text = 'DSH 上次中断，任务执行结果未知；为避免重复操作，没有自动重跑。请检查本机后重新发起。'
       } else if (state.status === 'completed' && entry.reply) text = entry.reply
@@ -1494,10 +1604,15 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
       else return
       const outcome = state.outcome || (state.status === 'expired' ? 'expired' : state.status)
       const current = await ledger.put({ ...entry, status: outcome, outcome,
-        reply: text, failure_reason: state.status === 'completed' ? null : text })
+        reply: text, failure_reason: state.status === 'completed' ? null : text, finish_error: null })
       await replyOwnerApprovalResult(current, text, connection)
     } catch (error) {
       logger.warn?.('ANT 主人审批状态恢复失败:', error?.message)
+      if (['claimed', 'running', 'finishing'].includes(entry.status)) {
+        await ledger.put({ ...entry, status: 'finishing',
+          finish_error: statusErrorText(error?.message) || '无法读取服务端审批状态；结果待核对。' })
+          .catch(() => undefined)
+      }
     }
   }
 
@@ -1708,17 +1823,36 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
     }
     if (event.conversation?.kind !== 'dm') return { accepted: true }
     const text = addressedText(event)
-    const ownerBinding = /^绑定审批身份\s+([a-f0-9]{12})$/iu.exec(text)
+    const ownerBindingCommand = /^绑定审批身份\s+([a-f0-9]{12})$/iu.exec(text)
+    const bareOwnerBindingCode = /^([a-f0-9]{12})$/iu.exec(text)
+    const ownerChallengeKey = event.fingerprint.toLowerCase()
+    const pendingOwnerChallenge = pendingOwnerChallenges.get(ownerChallengeKey)
+    const ownerBinding = ownerBindingCommand || (pendingOwnerChallenge && bareOwnerBindingCode)
     if (ownerBinding) {
+      const code = (ownerBindingCommand?.[1] || bareOwnerBindingCode[1]).toUpperCase()
+      if (pendingOwnerChallenge && pendingOwnerChallenge.expires_at <= Date.now()) {
+        pendingOwnerChallenges.delete(ownerChallengeKey)
+        await ctx.dshIm.replyChecked(event.botId, event.reply,
+          '审批私聊绑定未完成：绑定码已过期，请从 ANT“私聊入口”重新生成。',
+          { expectedFingerprint: event.fingerprint, signal: signal || controller.signal }).catch(() => undefined)
+        return { accepted: true }
+      }
+      if (pendingOwnerChallenge && code !== pendingOwnerChallenge.code) {
+        await ctx.dshIm.replyChecked(event.botId, event.reply,
+          '审批私聊绑定未完成：这不是当前机器人生成的绑定码；请从 ANT“私聊入口”复制最新验证码。',
+          { expectedFingerprint: event.fingerprint, signal: signal || controller.signal }).catch(() => undefined)
+        return { accepted: true }
+      }
       try {
         const result = await memberJson(connection, '/api/me/im-delegations/owner-bind', {
           method: 'POST', body: JSON.stringify({ bot_id: event.botId,
             bot_fingerprint: event.fingerprint, sender_id: event.actor.id,
-            code: ownerBinding[1].toUpperCase() }), signal,
+            code }), signal,
         })
         if (!result?.bound || typeof result.target_id !== 'string') {
           throw new Error('绑定码无效、已过期或尝试次数已用完。')
         }
+        pendingOwnerChallenges.delete(ownerChallengeKey)
         await ensureOwnerApprovalTarget(ctx, event.botId, event.fingerprint,
           event.actor.id, result.target_id)
         ownerBoundByFingerprint.set(event.fingerprint, true)
@@ -1750,6 +1884,9 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
             const available = runner === 'dsh' ? Boolean(ctx.sessionController && ctx.agents)
               : (() => { try { return (ctx.get?.('subagents') ?? ctx.subagents)?.list?.().includes(runner) === true } catch { return false } })()
             if (!available) throw new Error(`这台 DSH 尚未启用 ${runner} 子 Agent 提供方；审批仍保留，可改选其他执行器。`)
+            if (pending.card_task && runner !== pending.card_task.card.runner) {
+              throw new Error(`这项任务卡固定由 ${pending.card_task.card.runner} 执行；审批仍保留。`)
+            }
           }
           const result = await memberJson(connection,
             `/api/me/im-delegations/owner-approvals/${approvalId}/decision`, {
@@ -1768,10 +1905,22 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
                 method: 'POST', body: JSON.stringify({ request_sha256: pending.request_sha256, runner }), signal,
               })
             if (!claimed?.claimed) throw new Error('审批已被使用、已过期或权限状态已改变。')
-            const approved = await ledger.put({ ...pending, status: 'claimed', runner,
+            if (pending.card_task) {
+              await ledger.put({ ...pending, status: 'claimed', runner, decision_sender_id: event.actor.id,
+                decided_at: event.at })
+              await startApprovedCardTask(ledger.get(pending.key), connection)
+              await ctx.dshIm.replyChecked(event.botId, event.reply,
+                `已批准审批 ${approvalId}，任务已进入队列；完成后结果返回原会话。`,
+                { expectedFingerprint: event.fingerprint, signal: signal || controller.signal })
+                .catch((error) => logger.warn?.('ANT 主人审批回执发送失败:', error?.message))
+              return { accepted: true }
+            }
+            const taskId = createHash('sha256').update(`${pending.key}\0${pending.approval_id}`)
+              .digest('hex').slice(0, 10).toUpperCase()
+            const approved = await ledger.put({ ...pending, task_id: taskId, status: 'claimed', runner,
               decision_sender_id: event.actor.id, decided_at: event.at })
-            reply = `已批准审批 ${approvalId}，正在启动 ${runner}。完成后结果返回原会话。`
-            const work = executeOwnerApproval(approved, connection, controller.signal)
+            reply = `已批准审批 ${approvalId}，任务编号 ${taskId}，正在启动 ${runner}。可在 ANT 协作页查看状态或取消；完成后结果返回原会话。`
+            const work = executeOwnerApproval(approved, connection)
             processingTasks.add(work)
             void work.catch((error) => logger.warn?.('ANT 主人审批任务收尾失败:', error?.message))
               .finally(() => processingTasks.delete(work))
@@ -2059,10 +2208,32 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
       dmChatEnabledByFingerprint.set(fingerprint.toLowerCase(), enabled)
     }
   }
-  stop.recognizeRule = async (description) => {
-    await ready
+  stop.rememberOwnerChallenge = (fingerprint, code) => {
+    if (typeof fingerprint !== 'string' || !/^[a-f0-9]{64}$/iu.test(fingerprint)
+      || typeof code !== 'string' || !/^[a-f0-9]{12}$/iu.test(code)) return false
+    pendingOwnerChallenges.set(fingerprint.toLowerCase(), {
+      code: code.toUpperCase(), expires_at: Date.now() + 5 * 60_000,
+    })
+    return true
+  }
+  stop.ownerChallengeStatus = (fingerprint) => {
+    if (typeof fingerprint !== 'string' || !/^[a-f0-9]{64}$/iu.test(fingerprint)) return null
+    const key = fingerprint.toLowerCase()
+    const challenge = pendingOwnerChallenges.get(key)
+    if (!challenge || challenge.expires_at <= Date.now()) {
+      pendingOwnerChallenges.delete(key)
+      return { pending: false }
+    }
+    return { pending: true }
+  }
+  stop.cancelOwnerChallenge = (fingerprint) => {
+    if (typeof fingerprint !== 'string' || !/^[a-f0-9]{64}$/iu.test(fingerprint)) return false
+    return pendingOwnerChallenges.delete(fingerprint.toLowerCase())
+  }
+  stop.recognizeRule = async (description, requestSignal = null) => {
+    await waitForSignal(ready, requestSignal)
     if (stopped || !ledgerReady) throw new Error('本机协作服务尚未就绪，请稍后重试。')
-    return conversation.recognizeRule(description)
+    return conversation.recognizeRule(description, requestSignal)
   }
   stop.cancelTask = async (taskId, serviceUrl) => {
     await ready
@@ -2079,6 +2250,14 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
       }
       return true
     }
+    const approval = ledger.values().find((entry) => entry.kind === 'owner_approval'
+      && entry.task_id === taskId && entry.service_url === serviceUrl)
+    if (approval && ['claimed', 'running'].includes(approval.status)) {
+      const running = ownerApprovalTaskControllers.get(approval.key)
+      if (!running || running.finished) return false
+      running.controller.abort()
+      return true
+    }
     return conversation.cancelTask(taskId, serviceUrl)
   }
   return stop

package/index.js

@@ -6,6 +6,7 @@ import { readFile } from 'node:fs/promises'
 import { installSkill, listSkills, uninstallSkill } from './skill-install.js'
 import { readLocalDelegationSettings, recentDelegationStatus, startDelegationHost,
   writeLocalDelegationSettings } from './delegation.js'
+import { waitForSignal } from './conversation.js'
 
 export const inject = []
 
@@ -320,7 +321,7 @@ async function fetchDelegationBots(request, ctx) {
       try {
         const details = await service.describeBot(bot.botId)
         return {
-          bot_id: bot.botId, name: details.account?.name || bot.botId,
+          bot_id: bot.botId, channel: bot.channel, name: details.account?.name || bot.botId,
           fingerprint: details.account?.fingerprint,
           connected: details.connected === true,
           available: details.capabilities?.includes('exclusive-text-consumer')
@@ -385,14 +386,33 @@ async function fetchDelegationGrants(request, ctx, credentials, settings) {
 }
 
 async function fetchDelegationGroupSettings(request, ctx, credentials, settings, kind, getHost) {
-  const methods = kind === 'groups' ? ['GET', 'PUT'] : kind === 'dm-chat' ? ['PUT']
-    : kind === 'challenge' ? ['POST'] : ['GET', 'POST', 'DELETE']
+  const methods = kind === 'groups' ? ['GET', 'PUT'] : kind === 'dm-chat' ? ['PUT'] : ['GET', 'POST', 'DELETE']
   if (!methods.includes(request.method)) return jsonResponse(405, { message: '请求方式不支持。' })
+  if (kind === 'challenge' && request.method === 'DELETE') {
+    const fingerprint = new URL(request.url).searchParams.get('bot_fingerprint')
+    if (typeof fingerprint !== 'string' || !/^[a-f0-9]{64}$/iu.test(fingerprint)) {
+      return jsonResponse(400, { message: '请求格式无效。' })
+    }
+    const host = getHost?.()
+    if (!host?.cancelOwnerChallenge) {
+      return jsonResponse(503, { message: '本机协作收件尚未就绪，请稍后刷新后重新生成绑定码。' })
+    }
+    return jsonResponse(200, { cancelled: host.cancelOwnerChallenge(fingerprint) })
+  }
   let connection
   try { connection = await readMemberConnection(credentials, settings) } catch {
     return jsonResponse(500, { message: '无法读取 ANT 连接。' })
   }
   if (!connection) return jsonResponse(401, { message: '请先连接 ANT 团队。' })
+  if (kind === 'challenge' && request.method === 'GET') {
+    const fingerprint = new URL(request.url).searchParams.get('bot_fingerprint')
+    if (typeof fingerprint !== 'string' || !/^[a-f0-9]{64}$/iu.test(fingerprint)) {
+      return jsonResponse(400, { message: '请求格式无效。' })
+    }
+    const status = getHost?.()?.ownerChallengeStatus?.(fingerprint)
+    if (!status) return jsonResponse(503, { message: '本机协作收件尚未就绪，请稍后刷新后重新生成绑定码。' })
+    return jsonResponse(200, status)
+  }
   let body = null
   if (request.method !== 'GET') {
     try {
@@ -451,6 +471,16 @@ async function fetchDelegationGroupSettings(request, ctx, credentials, settings,
     }
     const text = await readLimitedBody(response)
     if (text === null) return jsonResponse(502, { message: '团队服务响应过大。' })
+    if (kind === 'challenge' && request.method === 'POST' && response.ok) {
+      let challenge
+      try { challenge = JSON.parse(text) } catch {
+        return jsonResponse(502, { message: '团队服务返回的绑定码格式无效。' })
+      }
+      const host = getHost?.()
+      if (!host?.rememberOwnerChallenge?.(body.bot_fingerprint, challenge?.code)) {
+        return jsonResponse(503, { message: '本机协作收件尚未就绪，请稍后刷新后重新生成绑定码。' })
+      }
+    }
     if (kind === 'groups' && request.method === 'GET' && response.ok) {
       try {
         const groups = JSON.parse(text)
@@ -566,9 +596,10 @@ async function fetchDelegationCards(request, ctx, credentials, settings) {
 async function fetchDelegationRuleRecognition(request, credentials, settings, getHost) {
   if (request.method !== 'POST') return jsonResponse(405, { message: '只支持 POST 请求。' })
   try {
-    const connection = await readMemberConnection(credentials, settings)
+    request.signal.throwIfAborted()
+    const connection = await waitForSignal(readMemberConnection(credentials, settings), request.signal)
     if (!connection) return jsonResponse(401, { message: '请先连接 ANT 团队。' })
-    const raw = await request.text()
+    const raw = await waitForSignal(request.text(), request.signal)
     if (raw.length > 8_192) return jsonResponse(413, { message: '规则描述过长。' })
     let body
     try { body = JSON.parse(raw) } catch { return jsonResponse(400, { message: '规则识别请求格式无效。' }) }
@@ -577,7 +608,7 @@ async function fetchDelegationRuleRecognition(request, credentials, settings, ge
     }
     const host = getHost?.()
     if (!host?.recognizeRule) return jsonResponse(503, { message: '本机 DSH 协作会话尚未就绪，请稍后重试。' })
-    return jsonResponse(200, await host.recognizeRule(body.description))
+    return jsonResponse(200, await host.recognizeRule(body.description, request.signal))
   } catch (error) {
     return jsonResponse(502, { message: error?.message || '任务规则识别失败，请稍后重试。' })
   }
@@ -1166,7 +1197,7 @@ export function apply(ctx) {
       [DELEGATION_ENROLLED_BOTS_PATH, ['GET', 'POST', 'DELETE'], 'bots'],
       [DELEGATION_GROUPS_PATH, ['GET', 'PUT'], 'groups'],
       [DELEGATION_DM_CHAT_PATH, ['PUT'], 'dm-chat'],
-      [DELEGATION_OWNER_CHALLENGE_PATH, ['POST'], 'challenge'],
+      [DELEGATION_OWNER_CHALLENGE_PATH, ['GET', 'POST', 'DELETE'], 'challenge'],
     ]) {
       connectionCtx.effect(() => connectionCtx.connection.fetch.register({
         path, methods, requestBody: 'buffered',