新增: 无人值守P0任务边界全链

- 任务级授权边界判定与审批旁路单点插桩 - boundary_json 随会话落库(V45 可逆迁移) - 六路非正常终局统一安全停靠与托盘通知 - 每五轮进度事件与会话头部进度条 - 前端边界配置卡侧栏徽标及 UX 校验补齐
2026-10-04 16:27:30 +08:00
parent 8396849d04
commit b2d44f85e9
29 changed files with 2773 additions and 142 deletions
@@ -2,7 +2,7 @@

 import { invoke } from '@tauri-apps/api/core'
 import { listen, type UnlistenFn } from '@tauri-apps/api/event'
-import type { AiChatEvent, AiConversationDetail, AiConversationSummary, AiProviderConfig, AiToolMeta, ContentPart, MentionSpan, ModelConfig, SkillInfo } from './types'
+import type { AiChatEvent, AiConversationDetail, AiConversationSummary, AiProviderConfig, AiToolMeta, ContentPart, MentionSpan, ModelConfig, SkillInfo, TaskBoundary } from './types'

 export const aiApi = {
  /**
@@ -112,6 +112,19 @@ export const aiApi = {
    return invoke('ai_pending_tool_calls', { conversationId })
  },

+  // ── 无人值守任务边界(设计 §2.3):发起时一次授权,存续期生效,随会话同亡 ──
+
+  /** 读取会话任务边界(配置卡回显/侧栏徽标)。无边界返回 null(幂等读不报错) */
+  getTaskBoundary(conversationId: string): Promise<TaskBoundary | null> {
+    return invoke('ai_task_boundary_get', { conversationId })
+  },
+
+  /** 设置会话任务边界。boundary 传 null = 清除,回退逐次审批;
+   *  后端把 risk_ceiling=high 钳到 medium;对话未落库时内存即生效,首条消息落库随行 */
+  setTaskBoundary(conversationId: string, boundary: TaskBoundary | null): Promise<void> {
+    return invoke('ai_task_boundary_set', { conversationId, boundary })
+  },
+
  /** 清空对话 */
  clearChat(): Promise<void> {
    return invoke('ai_chat_clear')
@@ -378,6 +391,15 @@ export const aiApi = {
    return invoke('ai_conversation_peek', { conversationId })
  },

+  /**
+   * 按父会话反查子代理轨迹精简元数据(P2-2 完成卡回补数据源,只读无副作用)。
+   * 后端按 origin='sub_agent' + id 前缀约定过滤,created_at 升序(轨迹时间线序)。
+   * 重启/分离窗回收后内存完成卡清零,经此按父 conv 重建卡片入口。
+   */
+  listSubAgents(conversationId: string): Promise<{ conversation_id: string; title: string | null; created_at: string }[]> {
+    return invoke('ai_sub_agent_list', { conversationId })
+  },
+
  /**
   * S4 TaskDrawer「关联会话」:按任务 id 反查发起过 create/update/advance_task 的会话。
   * 后端从 ai_tool_executions 审计表推导(result JSON 顶层 id 精确判等,非 LIKE),
@@ -480,6 +480,19 @@ export type AiChatEvent = ({
  // 前端渲染求助卡显 reason + options 按钮供用户选,与 AiApprovalRequired(工具执行前审批)/
  // AiMaxRoundsReached(达 max 被动截断)语义区分——求助=AI 主动「我搞不定」。
  type: 'AiHelpRequired'; reason: string; context: string; options: string[]
+} | {
+  // 无人值守安全停靠(设计 §四,挂起家族终局):六路非正常终局(审批超时取消/挂起后取消/
+  // 熔断/预算耗尽/Fatal/流中断)统一出口。语义:现场已保存、generating 已复位(非死等),reason 即
+  // 待办清单(停止原因+被拒操作提示),前端渲染停靠操作卡(继续续跑/停止归档)。
+  // stop_kind 词表(后端契约钉死,复用 AiAgentFinished 词表扩展):approval_timeout / cancelled /
+  // circuit_breaker / stall_breaker / max_rounds / fatal / midstream;后端新增变体时前端未知值中性兜底。
+  type: 'AiTaskParked'; reason: string; stop_kind?: string
+} | {
+  // 无人值守进度可观测(设计 §4.3):后端主 loop 每 5 轮 emit,长任务静默期(子代理长跑/
+  // 大工具执行/重入退避)可见「在干活」。round 1 起算;max_rounds=0=不限轮次(进度条只显轮次
+  // 与 token,不显分母)。事件即逝,前端 per-conv Map 存最近快照,终局(AiCompleted/AiError/
+  // AiHelpRequired/AiTaskParked)与会话删除时清理。
+  type: 'AiTaskProgress'; round: number; max_rounds: number; tokens_used: number
 } | {
  // L2 统一状态机(批2 1b/1c):ConvState 经 AiChatEvent 推前端,供 status union 消费。
  // conv_state 值为 idle|generating|stopping|error|compressed(snake_case,对齐后端 ConvState serde)。
@@ -806,6 +819,30 @@ export interface AiToolMeta {
  risk: 'low' | 'medium' | 'high'
 }

+// ============================================================
+// 无人值守长任务(设计 docs/02-架构设计/专项设计/无人值守长任务-设计-2026-10-04.md §二/§2.3)
+// 与后端 commands/ai/boundary.rs 严格对齐,snake_case 原样不做转译
+// ============================================================
+
+/** 任务预算(对齐后端 boundary::TaskBudget;null/缺省=不限,继承后端默认量纲) */
+export interface TaskBudget {
+  max_rounds: number
+  max_tokens: number
+  wall_secs: number
+}
+
+/**
+ * 任务级授权边界(挂会话,随会话同亡;发起时一次声明,存续期内 AI 全自主)。
+ * risk_ceiling serde lowercase;入口只允许 low/medium(后端 set 把 high 钳到 medium)。
+ * forbid_destructive 恒 true 仅展示,后端判定不读本字段。
+ */
+export interface TaskBoundary {
+  risk_ceiling: 'low' | 'medium' | 'high'
+  dir_allowlist: string[]
+  forbid_destructive: boolean
+  budget: TaskBudget | null
+}
+
 // ============================================================
 // 知识库
 // ============================================================
@@ -71,6 +71,10 @@
                <span v-if="store.isGenerating(conv.id)" class="ai-conv-gen-dot" :title="t('aiChat.generating')"></span>
                <!-- V1: 待审批徽标(橙点计数,复用既有 aiChat.pendingApprovalCount 文案) -->
                <span v-if="pendingCountOf(conv.id) > 0" class="ai-conv-approve-badge" :title="t('aiChat.pendingApprovalCount', { n: pendingCountOf(conv.id) })">{{ pendingCountOf(conv.id) }}</span>
+                <!-- 无人值守边界徽标:该会话已授权任务边界(镜像渐进填充);点击随会话切回显 -->
+                <span v-if="hasBoundary(conv.id)" class="ai-conv-boundary-badge" :title="t('ai.taskBoundary.badge')">
+                  <svg width="8" height="8" viewBox="0 0 24 24" fill="currentColor"><path d="M12 2 4 5v6c0 5 3.4 9.7 8 11 4.6-1.3 8-6 8-11V5l-8-3z"/></svg>
+                </span>
              </span>
              <span class="ai-conv-item-time">{{ formatRelative(conv.updated_at) }}</span>
            </div>
@@ -161,6 +165,10 @@
                  <span v-if="store.isGenerating(conv.id)" class="ai-conv-gen-dot" :title="t('aiChat.generating')"></span>
                  <!-- V1: 待审批徽标(橙点计数,复用既有 aiChat.pendingApprovalCount 文案) -->
                  <span v-if="pendingCountOf(conv.id) > 0" class="ai-conv-approve-badge" :title="t('aiChat.pendingApprovalCount', { n: pendingCountOf(conv.id) })">{{ pendingCountOf(conv.id) }}</span>
+                  <!-- 无人值守边界徽标:该会话已授权任务边界(镜像渐进填充);点击随会话切回显 -->
+                  <span v-if="hasBoundary(conv.id)" class="ai-conv-boundary-badge" :title="t('ai.taskBoundary.badge')">
+                    <svg width="8" height="8" viewBox="0 0 24 24" fill="currentColor"><path d="M12 2 4 5v6c0 5 3.4 9.7 8 11 4.6-1.3 8-6 8-11V5l-8-3z"/></svg>
+                  </span>
                </span>
                <span class="ai-conv-item-time">{{ formatRelative(conv.updated_at) }}</span>
              </div>
@@ -215,6 +223,10 @@
                  <span v-if="store.isGenerating(conv.id)" class="ai-conv-gen-dot" :title="t('aiChat.generating')"></span>
                  <!-- V1: 待审批徽标(橙点计数,复用既有 aiChat.pendingApprovalCount 文案) -->
                  <span v-if="pendingCountOf(conv.id) > 0" class="ai-conv-approve-badge" :title="t('aiChat.pendingApprovalCount', { n: pendingCountOf(conv.id) })">{{ pendingCountOf(conv.id) }}</span>
+                  <!-- 无人值守边界徽标:该会话已授权任务边界(镜像渐进填充);点击随会话切回显 -->
+                  <span v-if="hasBoundary(conv.id)" class="ai-conv-boundary-badge" :title="t('ai.taskBoundary.badge')">
+                    <svg width="8" height="8" viewBox="0 0 24 24" fill="currentColor"><path d="M12 2 4 5v6c0 5 3.4 9.7 8 11 4.6-1.3 8-6 8-11V5l-8-3z"/></svg>
+                  </span>
                </span>
                <span class="ai-conv-item-time">{{ formatRelative(conv.updated_at) }}</span>
              </div>
@@ -279,6 +291,9 @@ import { useI18n } from 'vue-i18n'
 import { useAiStore } from '../../stores/ai'
 // V1 只读消费:跨会话待审批真相源(state.pendingApprovals 仅是活跃会话投影,后台会话挂起不进投影)
 import { convPendingApprovals } from '../../composables/ai/aiShared'
+// 无人值守边界徽标只读消费:getConvBoundary 读镜像(reactive Map,模板内读取可追踪;
+// 镜像由边界配置卡在切会话/写入时渐进填充,无批量 IPC 属契约限制)
+import { getConvBoundary } from '../../composables/ai/useTaskBoundary'
 // UX走查 P2-7 只读订阅:rename/archive/pin 失败通知由 useAiConversations 发布,本组件弹就近 toast
 import { convOpFailNotice } from '../../composables/ai/useAiConversations'
 import { useToast } from '../../composables/useToast'
@@ -508,6 +523,11 @@ function pendingCountOf(convId: string): number {
  return pendingCountByConv.value.get(convId) ?? 0
 }

+/** 该会话是否已授权无人值守边界(徽标显隐)。直接读 reactive Map,渲染效应自动追踪增删 */
+function hasBoundary(convId: string): boolean {
+  return getConvBoundary(convId) !== null
+}
+
 // ── 对话分组:今天 / 昨天 / 更早 ──
 const bucketLabels = computed<Record<string, string>>(() => ({
  today: t('aiChat.today'),
@@ -842,6 +862,19 @@ body.ai-sidebar-resizing * {
  text-align: center;
  cursor: help;
 }
+/* 无人值守边界徽标(盾形,accent 色系与「已授权」语义一致;纯标记不计数) */
+.ai-conv-boundary-badge {
+  flex-shrink: 0;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 12px;
+  height: 12px;
+  border-radius: 6px;
+  background: color-mix(in srgb, var(--df-accent) 18%, transparent);
+  color: var(--df-accent);
+  cursor: help;
+}
 .ai-conv-item-actions {
  display: none;
  align-items: center;
@@ -0,0 +1,530 @@
+<template>
+  <!-- 无人值守边界配置卡(设计 §2.2):发起时一次性授权,存续期生效,随会话同亡。
+       默认收起(现状零变化);展开后对当前活跃会话 ai_task_boundary_set 一次拍板。
+       折叠行在有边界时只读回显摘要(数据源镜像,拉取见下);任务 generating 中锁编辑
+       (中途改边界=边跑边扩权,设计明令禁止)。不引入对话框,最小折叠卡。 -->
+  <div class="ai-boundary">
+    <button type="button" class="ai-boundary-toggle" @click="toggleOpen">
+      <svg class="ai-boundary-chevron" :class="{ 'is-open': open }" width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><polyline points="9 18 15 12 9 6"/></svg>
+      <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/></svg>
+      <span class="ai-boundary-toggle-label">{{ t('ai.taskBoundary.toggle') }}</span>
+      <span v-if="current" class="ai-boundary-echo">{{ echoSummary }}</span>
+    </button>
+
+    <div v-if="open" class="ai-boundary-body">
+      <div v-if="locked" class="ai-boundary-locked">{{ t('ai.taskBoundary.lockedGenerating') }}</div>
+
+      <!-- 拉取失败 ≠ 无边界:失败态禁「一次授权」(防默认空表单覆盖原授权),保留表单现状供重试 -->
+      <div v-if="loadFailed" class="ai-boundary-loadfail">
+        <span>{{ t('ai.taskBoundary.loadFailed') }}</span>
+        <button type="button" class="ai-boundary-mini-btn" @click="retryHydrate">{{ t('ai.taskBoundary.retryLoad') }}</button>
+      </div>
+
+      <div class="ai-boundary-row">
+        <span class="ai-boundary-label">{{ t('ai.taskBoundary.riskCeiling') }}</span>
+        <label class="ai-boundary-radio" :class="{ 'is-checked': risk === 'low' }">
+          <input v-model="risk" type="radio" value="low" :disabled="locked" />
+          <span>{{ t('ai.taskBoundary.riskLow') }}</span>
+        </label>
+        <label class="ai-boundary-radio" :class="{ 'is-checked': risk === 'medium' }">
+          <input v-model="risk" type="radio" value="medium" :disabled="locked" />
+          <span>{{ t('ai.taskBoundary.riskMedium') }}</span>
+        </label>
+      </div>
+
+      <div class="ai-boundary-row ai-boundary-row--col">
+        <span class="ai-boundary-label">{{ t('ai.taskBoundary.dirs') }}</span>
+        <div v-if="dirs.length" class="ai-boundary-dirs">
+          <span v-for="d in dirs" :key="d" class="ai-boundary-dir">
+            <span class="ai-boundary-dir-path" :title="d">{{ d }}</span>
+            <button type="button" class="ai-boundary-dir-x" :disabled="locked" @click="removeDir(d)">×</button>
+          </span>
+        </div>
+        <span v-else class="ai-boundary-dim">{{ t('ai.taskBoundary.dirEmpty') }}</span>
+        <div class="ai-boundary-dir-add">
+          <input
+            v-model="dirInput"
+            class="ai-boundary-input"
+            type="text"
+            :placeholder="t('ai.taskBoundary.dirPlaceholder')"
+            :disabled="locked"
+            @keydown="onDirInputKeydown"
+          />
+          <button type="button" class="ai-boundary-mini-btn" :disabled="locked || !dirInput.trim()" @click="addDir">{{ t('ai.taskBoundary.dirAdd') }}</button>
+        </div>
+        <!-- A2: 坏输入就近红字(非法字符/相对路径),不弹窗;存在性不阻断(白名单目录可尚不存在) -->
+        <span v-if="dirError" class="ai-boundary-dir-err">{{ dirError === 'illegal' ? t('ai.taskBoundary.dirErrIllegal') : t('ai.taskBoundary.dirErrRelative') }}</span>
+      </div>
+
+      <div class="ai-boundary-row">
+        <span class="ai-boundary-label">{{ t('ai.taskBoundary.forbidDestructive') }}</span>
+      </div>
+
+      <button type="button" class="ai-boundary-budget-toggle" @click="budgetOpen = !budgetOpen">
+        <svg class="ai-boundary-chevron" :class="{ 'is-open': budgetOpen }" width="9" height="9" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><polyline points="9 18 15 12 9 6"/></svg>
+        {{ t('ai.taskBoundary.budgetToggle') }}
+      </button>
+      <div v-if="budgetOpen" class="ai-boundary-budget">
+        <label class="ai-boundary-field">
+          <span>{{ t('ai.taskBoundary.budgetRounds') }}</span>
+          <input v-model="rounds" class="ai-boundary-input ai-boundary-input--num" type="text" inputmode="numeric" :disabled="locked" />
+        </label>
+        <label class="ai-boundary-field">
+          <span>{{ t('ai.taskBoundary.budgetTokens') }}</span>
+          <input v-model="tokens" class="ai-boundary-input ai-boundary-input--num" type="text" inputmode="numeric" :disabled="locked" />
+        </label>
+        <label class="ai-boundary-field">
+          <span>{{ t('ai.taskBoundary.budgetWallSecs') }}</span>
+          <input v-model="wallSecs" class="ai-boundary-input ai-boundary-input--num" type="text" inputmode="numeric" :disabled="locked" />
+        </label>
+        <span class="ai-boundary-dim">{{ t('ai.taskBoundary.budgetHint') }}</span>
+      </div>
+
+      <div class="ai-boundary-actions">
+        <button type="button" class="ai-boundary-confirm" :disabled="locked || loadFailed" @click="confirmSet">{{ t('ai.taskBoundary.confirmSet') }}</button>
+        <!-- A3: 清除=收权(安全向),generating 中保持可用,与字段编辑锁分离;有 confirm 二次确认 -->
+        <button v-if="current" type="button" class="ai-boundary-clear" @click="clearBoundary">{{ t('ai.taskBoundary.clearBoundary') }}</button>
+      </div>
+    </div>
+
+    <!-- 清除边界二次确认(运行中收权=后续工具回到逐次审批,须用户拍板;useConfirm 每实例独立 ref) -->
+    <ConfirmDialog :visible="confirmState.visible" :msg="confirmState.msg" :danger-label="t('ai.taskBoundary.clearBoundary')" @result="answerConfirm" />
+  </div>
+</template>
+
+<script setup lang="ts">
+// 无人值守边界配置卡:字段宁少勿预留(设计 §2.2)。目录白名单用简化交互(文本添加+删除),
+// 不复刻设置页完整目录选择器;预算三项折叠,空=不限(不传 budget)。
+import { computed, onMounted, ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useAiStore } from '../../stores/ai'
+import { fetchConvBoundary, getConvBoundary, saveConvBoundary, isConvBoundaryFetchFailed } from '../../composables/ai/useTaskBoundary'
+import { useConfirm } from '../../composables/useConfirm'
+import ConfirmDialog from '../ConfirmDialog.vue'
+import type { TaskBoundary } from '../../api/types'
+
+const emit = defineEmits<{
+  (e: 'toast', payload: { msg: string; type: 'error' | 'warning' | 'info' | 'success' }): void
+}>()
+
+const store = useAiStore()
+const { t } = useI18n()
+// 清除边界二次确认(A3);useConfirm 每调用独立 ref,不与 AiChat 的实例串台
+const { confirmState, confirmDialog, answerConfirm } = useConfirm()
+
+// 收起为默认态(未展开 = 现状逐次审批,零行为变化)
+const open = ref(false)
+const risk = ref<'low' | 'medium'>('low')
+const dirs = ref<string[]>([])
+const dirInput = ref('')
+// A2: 目录输入词法校验结果(空串=无错;illegal=含非法字符;relative=非绝对路径)
+const dirError = ref<'' | 'illegal' | 'relative'>('')
+// A1: 边界拉取失败态(≠ 无边界;禁「一次授权」防默认空表单覆盖原授权)
+const loadFailed = ref(false)
+const budgetOpen = ref(false)
+const rounds = ref('')
+const tokens = ref('')
+const wallSecs = ref('')
+
+const activeId = computed(() => store.state.activeConversationId)
+// 生成中锁编辑:防「边跑边扩权」。isGenerating 派生自 convStates reactive Map,computed 内可追踪
+const locked = computed(() => store.isGenerating(activeId.value))
+// 当前会话已授权边界(镜像;折叠行回显摘要数据源)
+const current = computed(() => getConvBoundary(activeId.value))
+
+function resetForm(): void {
+  risk.value = 'low'
+  dirs.value = []
+  dirInput.value = ''
+  dirError.value = ''
+  budgetOpen.value = false
+  rounds.value = ''
+  tokens.value = ''
+  wallSecs.value = ''
+}
+
+/** 从镜像回填表单(展开或切会话时调);镜像 miss 先拉一次再回填。
+ *  A1: 拉取失败与「确认无边界」分流——失败态置 loadFailed 禁授权,表单保留现状不清空 */
+async function hydrate(): Promise<void> {
+  const id = activeId.value
+  if (!id) {
+    resetForm()
+    loadFailed.value = false
+    return
+  }
+  await fetchConvBoundary(id)
+  if (activeId.value !== id) return
+  if (isConvBoundaryFetchFailed(id)) {
+    loadFailed.value = true
+    return
+  }
+  loadFailed.value = false
+  const b = getConvBoundary(id)
+  if (!b) {
+    resetForm()
+    return
+  }
+  // 单选只提供 low/medium(后端把 high 钳到 medium);万一存量 high 回显按 medium 呈现
+  risk.value = b.risk_ceiling === 'medium' || b.risk_ceiling === 'high' ? 'medium' : 'low'
+  dirs.value = [...b.dir_allowlist]
+  rounds.value = b.budget ? String(b.budget.max_rounds) : ''
+  tokens.value = b.budget ? String(b.budget.max_tokens) : ''
+  wallSecs.value = b.budget ? String(b.budget.wall_secs) : ''
+  budgetOpen.value = !!b.budget
+}
+
+/** 失败态重试(错误条按钮):重走拉取+回填 */
+function retryHydrate(): void {
+  void hydrate()
+}
+
+function toggleOpen(): void {
+  open.value = !open.value
+  if (open.value) void hydrate()
+}
+
+// 切会话:预拉边界喂侧栏徽标镜像;展开态走 hydrate(内含拉取)重填表单,防上一会话表单串台
+watch(activeId, (id) => {
+  if (!id) return
+  if (open.value) void hydrate()
+  else void fetchConvBoundary(id)
+})
+onMounted(() => {
+  if (activeId.value) void fetchConvBoundary(activeId.value)
+})
+
+/** 目录输入词法校验(A2,只做本地词法;存在性不阻断——白名单目录可尚不存在,后端
+ *  运行期 canonicalize 本就是 best-effort)。非法字符:Windows 保留集(冒号仅盘符位合法);
+ *  相对路径:须盘符/UNC/POSIX 根开头。返回空串=合法 */
+function validateDirInput(d: string): '' | 'illegal' | 'relative' {
+  const body = /^[a-zA-Z]:/.test(d) ? d.slice(2) : d
+  if (/[<>:"|?*]/.test(body) || /[\u0000-\u001f]/.test(d)) return 'illegal'
+  const isAbsolute = /^[a-zA-Z]:[\\/]/.test(d) || d.startsWith('\\\\') || d.startsWith('/')
+  if (!isAbsolute) return 'relative'
+  return ''
+}
+
+function addDir(): void {
+  const d = dirInput.value.trim()
+  if (!d) return
+  const err = validateDirInput(d)
+  if (err) {
+    dirError.value = err
+    return
+  }
+  dirError.value = ''
+  if (!dirs.value.includes(d)) dirs.value.push(d)
+  dirInput.value = ''
+}
+
+// 输入变化即清红字(改一个字就该有机会过下一轮校验,红字只描述当前输入的上一态)
+watch(dirInput, () => {
+  if (dirError.value) dirError.value = ''
+})
+
+/** 目录输入回车即添加;IME 组词中的回车属选词非提交,放行给输入法 */
+function onDirInputKeydown(e: KeyboardEvent): void {
+  if (e.isComposing || e.keyCode === 229) return
+  if (e.key === 'Enter') {
+    e.preventDefault()
+    addDir()
+  }
+}
+
+function removeDir(d: string): void {
+  dirs.value = dirs.value.filter(x => x !== d)
+}
+
+/** 预算三项解析:全空=undefined(不限);任一非空但非正整数视为无效返回 null */
+function parseBudget(): { max_rounds: number; max_tokens: number; wall_secs: number } | undefined | null {
+  const fields = [
+    { v: rounds.value.trim(), min: 1 },
+    { v: tokens.value.trim(), min: 1 },
+    { v: wallSecs.value.trim(), min: 1 },
+  ]
+  if (fields.every(f => !f.v)) return undefined
+  const nums: number[] = []
+  for (const f of fields) {
+    if (!f.v) {
+      nums.push(0)
+      continue
+    }
+    const n = Number(f.v)
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) return null
+    nums.push(n)
+  }
+  return { max_rounds: nums[0], max_tokens: nums[1], wall_secs: nums[2] }
+}
+
+/** 一次授权:set 当前活跃会话边界并收卡。未落库会话后端内存即生效,首条消息落库随行 */
+async function confirmSet(): Promise<void> {
+  const id = activeId.value
+  if (!id || locked.value || loadFailed.value) return
+  const budget = parseBudget()
+  if (budget === null) {
+    emit('toast', { msg: t('ai.taskBoundary.budgetInvalid'), type: 'warning' })
+    return
+  }
+  const boundary: TaskBoundary = {
+    risk_ceiling: risk.value,
+    dir_allowlist: dirs.value.slice(),
+    forbid_destructive: true,
+    budget: budget ?? null,
+  }
+  try {
+    await saveConvBoundary(id, boundary)
+    open.value = false
+    emit('toast', { msg: t('ai.taskBoundary.setOk'), type: 'success' })
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    emit('toast', { msg: t('ai.taskBoundary.setFail', { msg }), type: 'error' })
+  }
+}
+
+/** 清除边界:set null,回退逐次审批(接管转人工语义),可随时重新授权。
+ *  A3: 收权是安全向,不受 generating 编辑锁限制(任务跑偏时可立即收回授权,唯一出路
+ *  不该是停掉整个任务);因运行中收权影响后续工具审批方式,加 confirm 二次确认 */
+async function clearBoundary(): Promise<void> {
+  const id = activeId.value
+  if (!id) return
+  if (!await confirmDialog(t('ai.taskBoundary.clearConfirm'))) return
+  try {
+    await saveConvBoundary(id, null)
+    resetForm()
+    emit('toast', { msg: t('ai.taskBoundary.clearOk'), type: 'info' })
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    emit('toast', { msg: t('ai.taskBoundary.setFail', { msg }), type: 'error' })
+  }
+}
+
+// 折叠行只读回显摘要:「已授权 · 风险上限 中 · 2 个目录 · 预算不限」
+const echoSummary = computed(() => {
+  const b = current.value
+  if (!b) return ''
+  const riskWord = b.risk_ceiling === 'low'
+    ? t('ai.taskBoundary.riskLow')
+    : b.risk_ceiling === 'medium'
+      ? t('ai.taskBoundary.riskMedium')
+      : t('ai.agentTrace.riskHigh') // 存量 high 边界回显(单选已不产出 high,兜底转 i18n 不直出裸串)
+  const parts = [
+    t('ai.taskBoundary.echoRisk', { risk: riskWord }),
+    t('ai.taskBoundary.echoDirs', { n: b.dir_allowlist.length }),
+    b.budget
+      ? t('ai.taskBoundary.echoBudget', { rounds: b.budget.max_rounds, tokens: b.budget.max_tokens, secs: b.budget.wall_secs })
+      : t('ai.taskBoundary.echoNoBudget'),
+  ]
+  return parts.join(' · ')
+})
+</script>
+
+<style scoped>
+/* 输入区上方的轻量折叠条,视觉克制度对齐 .ai-input-hint(不抢输入框焦点注意力) */
+.ai-boundary {
+  margin-bottom: 4px;
+  font-size: 11px;
+  color: var(--df-text-dim);
+}
+.ai-boundary-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 2px 4px;
+  border: none;
+  background: none;
+  color: var(--df-text-dim);
+  font-size: 11px;
+  cursor: pointer;
+  border-radius: var(--df-radius-sm, 4px);
+  max-width: 100%;
+}
+.ai-boundary-toggle:hover { color: var(--df-text); }
+.ai-boundary-chevron {
+  transition: transform 0.15s var(--df-ease);
+  flex-shrink: 0;
+}
+.ai-boundary-chevron.is-open { transform: rotate(90deg); }
+.ai-boundary-toggle-label { font-weight: 600; }
+.ai-boundary-echo {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--df-accent);
+  opacity: 0.85;
+}
+.ai-boundary-body {
+  margin-top: 4px;
+  display: flex;
+  flex-direction: column;
+  gap: 7px;
+  padding: 8px;
+  background: color-mix(in srgb, var(--df-accent) 5%, transparent);
+  border: 0.5px solid color-mix(in srgb, var(--df-accent) 20%, transparent);
+  border-radius: var(--df-radius);
+}
+.ai-boundary-locked {
+  font-size: 10.5px;
+  color: var(--df-warning);
+}
+.ai-boundary-loadfail {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px;
+  font-size: 10.5px;
+  color: var(--df-danger);
+}
+.ai-boundary-dir-err {
+  font-size: 10.5px;
+  color: var(--df-danger);
+}
+.ai-boundary-row {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+.ai-boundary-row--col {
+  flex-direction: column;
+  align-items: stretch;
+  gap: 5px;
+}
+.ai-boundary-label {
+  font-weight: 600;
+  color: var(--df-text);
+}
+.ai-boundary-radio {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  cursor: pointer;
+  color: var(--df-text-dim);
+}
+.ai-boundary-radio.is-checked { color: var(--df-accent); }
+.ai-boundary-radio input { accent-color: var(--df-accent); margin: 0; }
+.ai-boundary-radio:has(input:disabled) { cursor: not-allowed; opacity: 0.6; }
+.ai-boundary-dirs {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+.ai-boundary-dir {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+  padding: 1px 4px;
+  background: var(--df-bg-card);
+  border: 0.5px solid var(--df-border);
+  border-radius: calc(var(--df-radius) - 2px);
+  font-size: 10.5px;
+  color: var(--df-text);
+  max-width: 100%;
+}
+.ai-boundary-dir-path {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  direction: rtl;
+  font-family: var(--df-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace);
+}
+.ai-boundary-dir-x {
+  border: none;
+  background: none;
+  color: var(--df-text-dim);
+  cursor: pointer;
+  font-size: 12px;
+  line-height: 1;
+  padding: 0 2px;
+}
+.ai-boundary-dir-x:hover:not(:disabled) { color: var(--df-danger); }
+.ai-boundary-dir-x:disabled { cursor: not-allowed; opacity: 0.5; }
+.ai-boundary-dir-add {
+  display: flex;
+  gap: 4px;
+}
+.ai-boundary-input {
+  flex: 1;
+  min-width: 0;
+  font-size: 11px;
+  padding: 2px 6px;
+  background: var(--df-bg-card);
+  color: var(--df-text);
+  border: 0.5px solid var(--df-border);
+  border-radius: calc(var(--df-radius) - 2px);
+  outline: none;
+}
+.ai-boundary-input:focus { border-color: color-mix(in srgb, var(--df-accent) 40%, transparent); }
+.ai-boundary-input:disabled { opacity: 0.5; cursor: not-allowed; }
+.ai-boundary-input--num { flex: 0 0 90px; }
+.ai-boundary-mini-btn {
+  border: 0.5px solid var(--df-border);
+  background: var(--df-bg-card);
+  color: var(--df-text-dim);
+  font-size: 11px;
+  padding: 2px 8px;
+  cursor: pointer;
+  border-radius: calc(var(--df-radius) - 2px);
+  flex-shrink: 0;
+}
+.ai-boundary-mini-btn:hover:not(:disabled) { color: var(--df-text); }
+.ai-boundary-mini-btn:disabled { cursor: not-allowed; opacity: 0.5; }
+.ai-boundary-budget-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  border: none;
+  background: none;
+  padding: 0;
+  color: var(--df-text-dim);
+  font-size: 11px;
+  cursor: pointer;
+  align-self: flex-start;
+}
+.ai-boundary-budget-toggle:hover { color: var(--df-text); }
+.ai-boundary-budget {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+.ai-boundary-field {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  color: var(--df-text-dim);
+  white-space: nowrap;
+}
+.ai-boundary-dim {
+  font-size: 10px;
+  opacity: 0.7;
+}
+.ai-boundary-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.ai-boundary-confirm {
+  border: none;
+  background: var(--df-accent);
+  color: #fff;
+  font-size: 11px;
+  font-weight: 600;
+  padding: 4px 10px;
+  cursor: pointer;
+  border-radius: calc(var(--df-radius) - 2px);
+  transition: background 0.15s var(--df-ease);
+}
+.ai-boundary-confirm:hover:not(:disabled) { background: var(--df-accent-hover); }
+.ai-boundary-confirm:disabled { opacity: 0.5; cursor: not-allowed; }
+.ai-boundary-clear {
+  border: 0.5px solid var(--df-border);
+  background: transparent;
+  color: var(--df-text-dim);
+  font-size: 11px;
+  padding: 4px 10px;
+  cursor: pointer;
+  border-radius: calc(var(--df-radius) - 2px);
+}
+.ai-boundary-clear:hover:not(:disabled) { color: var(--df-danger); border-color: var(--df-danger); }
+.ai-boundary-clear:disabled { cursor: not-allowed; opacity: 0.5; }
+</style>
@@ -0,0 +1,170 @@
+<template>
+  <!-- 无人值守安全停靠卡(设计 §四):后端非正常终局(六路,stop_kind 词表见 i18n)emit AiTaskParked(已保存现场并复位
+       generating,非死等),useAiEvents/useAiLifecycleEvents 登记 pendingTaskParked(per-conv Map)
+       后本卡渲染。复用 HelpRequiredCard 模式:per-conv 守卫(挂起会话===当前展示会话)+ 行为后摘卡。
+       卡面 = reason 人话 + stop_kind 标签;操作两枚:继续(ai_continue_loop 重新授权续跑)/
+       停止归档(ai_chat_stop 既有停止路径,归档会话走侧栏既有入口,此处不代做)。
+       cancelled 例外只显停止归档(用户主动取消后不再诱导续跑)。 -->
+  <div v-if="parkedActive" ref="cardRef" class="ai-task-parked">
+    <div class="ai-task-parked-head">
+      <span class="ai-task-parked-tag" :class="kindClass">{{ kindLabel }}</span>
+      <span class="ai-task-parked-title">{{ t('ai.taskParked.title') }}</span>
+    </div>
+    <span class="ai-task-parked-reason">{{ parkedActive.reason }}</span>
+    <div class="ai-task-parked-actions">
+      <!-- cancelled(审批挂起中被用户主动取消)不显「继续」:用户刚点过停止,首位按钮再诱导续跑与意图相逆 -->
+      <button v-if="parkedActive.stopKind !== 'cancelled'" class="ai-task-parked-btn" :disabled="busy" @click="handleContinue">{{ t('aiChat.continueLoop') }}</button>
+      <button class="ai-task-parked-btn ai-task-parked-btn--muted" :disabled="busy" @click="handleStopArchive">{{ t('ai.taskParked.stopArchive') }}</button>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch, nextTick } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useAiStore } from '../../stores/ai'
+import { aiApi } from '../../api'
+import { pendingTaskParked } from '../../composables/ai/useAiPendingState'
+
+// toast 经 emit 转父(保持单一 toast 源,与 HelpRequiredCard 一致)
+const emit = defineEmits<{
+  (e: 'toast', payload: { msg: string; type: 'error' | 'warning' | 'info' }): void
+}>()
+
+const store = useAiStore()
+const { t } = useI18n()
+
+// 当前展示会话的停靠挂起(无则不渲染)。后端停靠已复位 generating,与 HelpRequiredCard 同理
+// 不依赖 streaming 判断显隐。Map 键控 per-conv,多会话各自停靠互不覆盖。
+const parkedActive = computed(() => {
+  const id = store.state.activeConversationId
+  if (!id) return null
+  return pendingTaskParked.get(id) ?? null
+})
+
+// stop_kind 词表(后端契约钉死):命中词表取对应文案与色级,未知值中性兜底(向后兼容后端新增变体)
+const KNOWN_KINDS = new Set(['approval_timeout', 'cancelled', 'circuit_breaker', 'stall_breaker', 'max_rounds', 'fatal', 'midstream'])
+const kindLabel = computed(() => {
+  const k = parkedActive.value?.stopKind
+  if (k && KNOWN_KINDS.has(k)) return t(`ai.taskParked.stopKind.${k}`)
+  return t('ai.taskParked.unknownKind')
+})
+// fatal 走 danger 红色(连续失败重入预算耗尽,警示级最高;语义上仍有「继续」路),其余 warning 琥珀
+const kindClass = computed(() => (parkedActive.value?.stopKind === 'fatal' ? 'ai-task-parked-tag--fatal' : ''))
+
+// 卡片根 ref。停靠常发生在多轮迭代后消息流已长,卡显时 scrollIntoView 让操作按钮立即可见
+const cardRef = ref<HTMLElement | null>(null)
+watch(parkedActive, async (p) => {
+  if (!p) return
+  await nextTick()
+  cardRef.value?.scrollIntoView({ block: 'center', behavior: 'smooth' })
+})
+
+// 操作进行中防重复点击(继续/停止都是 IPC 往返,连点会重复触发续跑/停止)
+const busy = ref(false)
+
+/** 继续:ai_continue_loop 重新授权续跑(预算重计=用户再授权语义);成功即摘卡 */
+async function handleContinue(): Promise<void> {
+  const convId = parkedActive.value?.conversationId
+  if (!convId || busy.value) return
+  busy.value = true
+  try {
+    await aiApi.continueLoop(convId)
+    pendingTaskParked.delete(convId)
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    emit('toast', { msg: t('aiChat.continueLoopFailed', { msg }), type: 'error' })
+  } finally {
+    busy.value = false
+  }
+}
+
+/** 停止归档:既有 ai_chat_stop 停止路径;停靠态 loop 已复位,此调用确保任何残留终局并落库,
+ *  成功后摘卡(用户不再续跑)。会话归档沿用侧栏既有入口,此处不代做避免不可逆误触 */
+async function handleStopArchive(): Promise<void> {
+  const convId = parkedActive.value?.conversationId
+  if (!convId || busy.value) return
+  busy.value = true
+  try {
+    await aiApi.stopChat(convId)
+    pendingTaskParked.delete(convId)
+    emit('toast', { msg: t('ai.taskParked.stoppedToast'), type: 'info' })
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    emit('toast', { msg: t('ai.taskParked.archiveFailed', { msg }), type: 'error' })
+  } finally {
+    busy.value = false
+  }
+}
+</script>
+
+<style scoped>
+/* 复用 HelpRequiredCard 样式基调(warning 色系,停靠属"需用户拍板"信号,视觉一致) */
+.ai-task-parked {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  margin-bottom: 6px;
+  padding: 6px 8px;
+  background: color-mix(in srgb, var(--df-warning) 10%, transparent);
+  border: 0.5px solid color-mix(in srgb, var(--df-warning) 40%, transparent);
+  border-radius: var(--df-radius);
+}
+.ai-task-parked-head {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+.ai-task-parked-tag {
+  flex-shrink: 0;
+  padding: 0 6px;
+  border-radius: calc(var(--df-radius) - 2px);
+  background: var(--df-warning);
+  color: #000;
+  font-size: 10px;
+  font-weight: 600;
+  line-height: 16px;
+}
+.ai-task-parked-tag--fatal {
+  background: var(--df-danger);
+  color: #fff;
+}
+.ai-task-parked-title {
+  font-size: 11.5px;
+  font-weight: 600;
+  color: var(--df-warning);
+}
+.ai-task-parked-reason {
+  font-size: 11px;
+  color: var(--df-text-dim);
+  opacity: 0.9;
+  word-break: break-word;
+  white-space: pre-wrap;
+}
+.ai-task-parked-actions {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin-top: 2px;
+}
+.ai-task-parked-btn {
+  border: 0.5px solid color-mix(in srgb, var(--df-warning) 60%, transparent);
+  background: var(--df-warning);
+  color: #000;
+  cursor: pointer;
+  font-size: 11px;
+  font-weight: 600;
+  padding: 3px 10px;
+  border-radius: calc(var(--df-radius) - 2px);
+  transition: filter 0.15s var(--df-ease);
+}
+.ai-task-parked-btn:hover { filter: brightness(1.1); }
+.ai-task-parked-btn:disabled { opacity: 0.5; cursor: not-allowed; }
+.ai-task-parked-btn--muted {
+  background: transparent;
+  color: var(--df-text-dim);
+  border-color: var(--df-border);
+}
+.ai-task-parked-btn--muted:hover { color: var(--df-text); }
+</style>
@@ -119,6 +119,20 @@
  <div class="ai-bottom-tools" ref="goalsRef">
    <span v-if="currentConvTitle" class="ai-bottom-title">{{ currentConvTitle }}</span>
    <div class="ai-bottom-tools-right">
+    <!-- 无人值守任务进度(AiTaskProgress,设计 §4.3):当前会话有进度快照时显示,
+         静默期(子代理长跑/大工具执行/重入退避)凭最后快照可见「在干活」;终局即清。
+         max_rounds=0(不限轮次)不显分母进度条,只显轮次与 token。 -->
+    <div v-if="taskProgress" class="ai-task-progress">
+      <span class="ai-task-progress-dot"></span>
+      <span class="ai-task-progress-text">{{ taskProgressText }}</span>
+      <span
+        v-if="taskProgress.maxRounds > 0"
+        class="ai-task-progress-bar"
+        :title="$t('ai.taskProgress.barHint', { round: taskProgress.round, max: taskProgress.maxRounds })"
+      >
+        <span class="ai-task-progress-fill" :style="{ width: taskProgressPct + '%' }"></span>
+      </span>
+    </div>
    <!-- 目标计数 -->
    <div v-if="goals.length" class="ai-goals-inline">
      <span class="ai-goals-inline-badge ai-tool-badge" @click="togglePanel('goals')" :title="$t('aiChat.viewGoals')">
@@ -217,6 +231,7 @@ import { ref, computed, watch, onMounted, onBeforeUnmount } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { useAiStore } from '../../stores/ai'
 import { aiApi } from '../../api/ai'
+import { pendingTaskProgress } from '../../composables/ai/useAiPendingState'
 import type { AiMessage, ModelConfig, GoalEntry } from '../../api/types'

 defineProps<{
@@ -356,6 +371,28 @@ const currentConvTitle = computed(() => {
  return conv?.title || ''
 })

+// ── 无人值守任务进度(设计 §4.3,AiTaskProgress per-conv 快照)──
+// 消费 useAiEvents 归集的 pendingTaskProgress(per-conv Map,终局即清):无快照不渲染。
+// 切会话自动跟随(Map 按 activeId 取),多会话并发各显各的,不串台。
+const taskProgress = computed(() => {
+  const id = store.state.activeConversationId
+  if (!id) return null
+  return pendingTaskProgress.get(id) ?? null
+})
+const taskProgressText = computed(() => {
+  const p = taskProgress.value
+  if (!p) return ''
+  const tokens = p.tokensUsed >= 1000 ? `${(p.tokensUsed / 1000).toFixed(1)}k` : String(p.tokensUsed)
+  return p.maxRounds > 0
+    ? t('ai.taskProgress.running', { round: p.round, max: p.maxRounds, tokens })
+    : t('ai.taskProgress.unlimited', { round: p.round, tokens })
+})
+const taskProgressPct = computed(() => {
+  const p = taskProgress.value
+  if (!p || p.maxRounds <= 0) return 0
+  return Math.min(100, Math.round((p.round / p.maxRounds) * 100))
+})
+
 // 🎯 对话目标面板(对话透明化 L1:Goal visibility)
 const goals = ref<GoalEntry[]>([])
 const goalsExpanded = ref(false)
@@ -744,7 +781,10 @@ onBeforeUnmount(() => {
  color: var(--df-text-secondary);
  min-width: 0;
  margin-right: auto;
-
+  /* 长标题单行截断(防换行撑高工具行;右侧徽章族 flex-shrink:0,分离窄窗口更挤) */
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 .ai-bottom-tools-right {
  display: flex;
@@ -753,6 +793,45 @@ onBeforeUnmount(() => {
  flex-shrink: 0;
  margin-left: auto;
 }
+/* 无人值守任务进度(设计 §4.3):绿点+轮次/token 文本+细进度条,与右侧徽章族同排 */
+.ai-task-progress {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  margin-right: 4px;
+  white-space: nowrap;
+}
+.ai-task-progress-dot {
+  width: 5px;
+  height: 5px;
+  border-radius: 50%;
+  background: var(--df-success);
+  flex-shrink: 0;
+  animation: ai-task-progress-pulse 1.6s ease-in-out infinite;
+}
+.ai-task-progress-text {
+  font-size: 11px;
+  color: var(--df-text-secondary);
+}
+.ai-task-progress-bar {
+  display: inline-block;
+  width: 48px;
+  height: 3px;
+  border-radius: 2px;
+  background: color-mix(in srgb, var(--df-text-dim) 25%, transparent);
+  overflow: hidden;
+}
+.ai-task-progress-fill {
+  display: block;
+  height: 100%;
+  border-radius: 2px;
+  background: var(--df-success);
+  transition: width .4s var(--df-ease);
+}
+@keyframes ai-task-progress-pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.35; }
+}
 /* ═══ Provider Bar (header 中间区) ═══ */
 .ai-provider-bar {
  display: inline-flex;
@@ -10,9 +10,10 @@ import { useAppSettingsStore } from '@/stores/appSettings'
 import { state } from '@/stores/ai'
 import { persistUiState } from './useAiPanel'
 import { setStreaming } from './streamingGuard'
-import { nextMsgId, getConvState, clearConvStreamState, clearLastDelta, startApprovalTimer, clearAllApprovalTimers, switchingConvs, getConvStreamState, setConvCurrentText, notifyConversationChanged, setConvPendingApprovals, discardConvPendingApprovals } from './aiShared'
+import { emitDetachedOpenConversation, registerDetachedOpenConvListener } from './useAiWindow'
+import { nextMsgId, getConvState, clearConvStreamState, clearLastDelta, startApprovalTimer, clearAllApprovalTimers, switchingConvs, getConvStreamState, setConvCurrentText, notifyConversationChanged, setConvPendingApprovals, discardConvPendingApprovals, backfillConvAgentFinished } from './aiShared'
 import { t } from '@/i18n/i18n-helpers'
-import type { AiConversationDetail, AiMessage, AiToolCallInfo, ConvId, MessageId } from '@/api/types'
+import type { AiConversationDetail, AiMessage, AiToolCallInfo, AiToolCallStatus, ConvId, MessageId } from '@/api/types'

 const appSettings = useAppSettingsStore()

@@ -154,6 +155,12 @@ function getLoadMoreState() {
  return loadMoreCursor
 }

+/** 会话是否处于在途生成态(非终止三态;switchConversation/loadMoreHistory 回载口径一致) */
+function isConvGenerating(convId: string): boolean {
+  const cs = getConvState(convId)
+  return cs === 'generating' || cs === 'stopping' || cs === 'compressed'
+}
+
 /**
 * 后端 ChatMessage[] → 前端 AiMessage[](switch + load_more 共用)。
 * 过滤/映射语义与 switchConversation 原内联逻辑逐行对齐(tool 消息 + truncated 软删剔除、
@@ -161,8 +168,12 @@ function getLoadMoreState() {
 * id:优先后端真实消息 id(DB 主键,prepend 时 v-for key 稳定),缺失兜底 `${fallbackPrefix}-${i}`
 * (老数据无 id / 旧 messages JSON 列)。fallbackPrefix 区分 switch('loaded')与 load_more('older'),
 * 防两条 id 方案在 prepend 后冲突。
+ * convGenerating:目标会话是否在途生成。主 loop 在工具执行前已落库带 tool_calls 的 assistant
+ * 消息,回载时无 tool_result 的 tool_call 不能恒标 completed(UX走查 P1-2:运行期切回父会话
+ * 见「已完成」幽灵态);在途时标 running 由后续 AiToolCallCompleted 按 id 推进终态。
+ * 会话不在生成(后端崩溃残留等)无更好真相,维持 completed 原行为。
 */
-function parseConvMessages(rawMsgs: any[], fallbackPrefix: string): AiMessage[] {
+function parseConvMessages(rawMsgs: any[], fallbackPrefix: string, convGenerating = false): AiMessage[] {
  // 构建 tool_call_id → tool_result 映射，用于回填工具执行结果
  const toolResultMap = new Map<string, string>()
  for (const m of rawMsgs) {
@@ -227,7 +238,9 @@ function parseConvMessages(rawMsgs: any[], fallbackPrefix: string): AiMessage[]
          id: tc.id,
          name: tc.function?.name || '',
          args,
-          status: 'completed' as const,
+          status: (toolResultMap.has(tc.id) || !convGenerating
+            ? 'completed'
+            : 'running') as AiToolCallStatus,
          result: toolResultMap.get(tc.id),
        }
      }),
@@ -248,7 +261,7 @@ async function loadMoreHistory(): Promise<boolean> {
    // 过期丢弃:等待期间用户切走/删除会话,游标已指向别的 conv → 不 prepend 错视图
    if (cur.convId !== state.activeConversationId) return false
    const rawMsgs = typeof res.messages === 'string' ? JSON.parse(res.messages) : res.messages
-    const older = parseConvMessages(rawMsgs, 'older')
+    const older = parseConvMessages(rawMsgs, 'older', isConvGenerating(cur.convId))
    // 按 id 去重(防御:游标边界变化 / 与已加载消息重复)
    const existing = new Set(state.messages.map(m => m.id))
    const fresh = older.filter(m => !existing.has(m.id))
@@ -272,12 +285,16 @@ async function loadMoreHistory(): Promise<boolean> {

 /** 切换到指定会话:加载历史消息(含 tool_calls 回填 + tool_result 映射 + pending 审批恢复)
 *  @param force true=跳过同会话短路(程序化刷新当前会话用:清空/压缩后回刷,如 AiChat.vue
- *         onCleared/onCompressed 回调);false(默认)=同会话点击直接 return。 */
-export async function switchConversation(id: string, force = false) {
+ *         onCleared/onCompressed 回调);false(默认)=同会话点击直接 return。
+ *  @param opts.noCreateFallback true=「对话不存在」时不再兜底新建会话,返回 'not_found'
+ *         交调用方反馈(UX走查 P3-7:程序化跳转命中已删会话,静默新建落空白对话)。
+ *  @returns 'not_found' 仅在 noCreateFallback 且目标会话不存在时;其余路径(含瞬态失败,
+ *           已保留原视图并推气泡)一律 'ok'。 */
+export async function switchConversation(id: string, force = false, opts?: { noCreateFallback?: boolean }): Promise<'ok' | 'not_found'> {
  // 同会话点击短路:已活跃会话不重拉。原实现无条件走 currentText='' + 全量 parse +
  // pending 重恢复,流式中点侧栏高亮项会清空流式文本、delta 从空续流 → 回复缺前缀。短路保留
  // in-flight 流式文本。程序化刷新(force=true)不受影响。
-  if (!force && id === state.activeConversationId) return
+  if (!force && id === state.activeConversationId) return 'ok'
  // 切换会话时清空所有审批计时器(防切走后过期 timer 误拒后台挂起审批 + 错误气泡推错视图)。
  // 新会话的审批计时器由下文恢复挂起路径的 startApprovalTimer 重新建立。
  clearAllApprovalTimers()
@@ -294,9 +311,14 @@ export async function switchConversation(id: string, force = false) {
    // 瞬态 IPC 失败(网络抖动/后端异常)保留原视图 + 推错误气泡,不再吞当前视图。
    const errMsg = e instanceof Error ? e.message : String(e)
    if (errMsg.includes('对话不存在')) {
+      // 程序化跳转(P3-7):目标已删不静默新建,留原视图由调用方就地反馈
+      if (opts?.noCreateFallback) {
+        console.warn('[AI] switchConversation: 会话不存在(已删除),保持原视图:', id)
+        return 'not_found'
+      }
      console.warn('[AI] switchConversation 失败(对话不存在),创建新对话:', id)
      const created = await aiApi.createConversation()
-      if (mySwitchId !== _latestSwitchId) return
+      if (mySwitchId !== _latestSwitchId) return 'ok'
      void appSettings.set('df-ai-active-conv', created.id)
      // 兜底置 activeId:此路径原只持久化不写 state.activeConversationId,旧(不存在)id 残留
      // 会让后续所有事件被 isCurrent 判为非当前而丢弃或误路由
@@ -313,15 +335,15 @@ export async function switchConversation(id: string, force = false) {
      setConvPendingApprovals(created.id, [])
      notifyConversationChanged()
      scheduleConversationsRefresh()
-      return
+      return 'ok'
    }
    // 瞬态失败:保留当前视图 + 错误气泡(复用会话操作失败气泡模式);过期响应丢弃。
    // 保留 scheduleConversationsRefresh():陈旧 id(已被后端删除)在下一次列表刷新中消失。
    console.error('[AI] switchConversation 失败(瞬态),保留当前视图:', e)
-    if (mySwitchId !== _latestSwitchId) return
+    if (mySwitchId !== _latestSwitchId) return 'ok'
    pushConvOpFail('switchConvFail')
    scheduleConversationsRefresh()
-    return
+    return 'ok'
  } finally {
    // 切换结束(含失败/过期/新建会话路径)清切换中标记 + 统一收集并清空缓冲。
    // 成功提交路径在下方用 _switchBufferedText 恢复续显;失败/过期路径缓冲被丢弃,
@@ -331,7 +353,7 @@ export async function switchConversation(id: string, force = false) {
    setConvCurrentText(id, '')
  }
  // 过期响应丢弃(用户已切到别的对话,防 A 后返回覆盖 B)
-  if (mySwitchId !== _latestSwitchId) return
+  if (mySwitchId !== _latestSwitchId) return 'ok'
  // 透传 has_more/earliest_seq 游标(前端滚顶加载更多历史)。
  // 后端在 generating/空对话等场景返 false/null,此处默认兜底。
  const switchDetailAny = detail as any
@@ -343,8 +365,7 @@ export async function switchConversation(id: string, force = false) {
  // (输入区 v-if=streaming)→ 点击停止会传 activeConversationId 发错会话。对齐新建会话的
  // 复位语义;目标在后台生成时保留 true(停止/流式显示正确)。读会话状态(枚举真相源)派生,
  // 桥接语义:非终止三态(generating/stopping/compressed)视为生成中。
-  const targetCs = getConvState(id)
-  const targetGen = targetCs === 'generating' || targetCs === 'stopping' || targetCs === 'compressed'
+  const targetGen = isConvGenerating(id)

  // 先 parse 成功替换 messages,成功后再置 activeConversationId(同一同步块内赋值,
  // 无 await 间隙 → 无中间态渲染)。原顺序先置 active 后 parse,parse 失败时 active 已是新 id 而
@@ -356,7 +377,8 @@ export async function switchConversation(id: string, force = false) {
    // 消息映射收敛进 parseConvMessages(切换 + 加载更多共用,过滤/映射语义一致)。
    // 相比原内联逻辑唯一行为变化:id 由 `loaded-${i}` 改为优先后端真实消息 id
    // (DB 主键,prepend 时 v-for key 稳定不重建 DOM),缺失才兜底 `loaded-${i}`。
-    state.messages = parseConvMessages(rawMsgs, 'loaded')
+    // targetGen 透传(UX走查 P1-2):在途回载时无结果的 tool_call 标 running。
+    state.messages = parseConvMessages(rawMsgs, 'loaded', targetGen)
    // parse 成功才置 active(保证 active 与 messages 一致)
    state.activeConversationId = id
    // 切到 round0 进行中的会话时,后端该轮 per_conv 只有 user 消息(assistant 占位
@@ -393,12 +415,17 @@ export async function switchConversation(id: string, force = false) {
      isError: true,
      timestamp: Date.now(),
    } as AiMessage)
-    return
+    return 'ok'
  }
  // 切换提交完成才持久化活跃会话 + 重算 streaming(active 已指向目标 conv)
  void appSettings.set('df-ai-active-conv', id)
  setStreaming(targetGen, { convId: id, reason: 'switchConversation-recompute' })

+  // P2-2 完成卡回补:重启/分离窗回收后内存卡清零,按父 conv 反查子代理轨迹重建。
+  // 启动恢复也走本函数(loadConversations 的 switchConversation(pending)),一处挂载全覆盖;
+  // fire-and-forget 不阻塞切换,幂等去重与静默降级见 backfillConvAgentFinished。
+  void backfillConvAgentFinished(id)
+
  // 加载历史对话 token 总量(来自 DB summary);切换对话清空实时值
  const conv = state.conversations.find(c => c.id === id)
  if (conv && conv.prompt_tokens != null && conv.completion_tokens != null) {
@@ -429,7 +456,7 @@ export async function switchConversation(id: string, force = false) {
    try {
      const pending = await aiApi.pendingToolCalls(id)
      // 第二 await 后二次比对:切换 A→B 期间避免用 A 的挂起覆写 B 的 pendingApprovals
-      if (mySwitchId !== _latestSwitchId) return
+      if (mySwitchId !== _latestSwitchId) return 'ok'
      if (pending.length) {
        // kind 索引:tool_call_id → kind('risk'/'path'),供恢复工具卡/挂起列表按类型渲染
        const pendingKindMap = new Map(pending.map(p => [p.tool_call_id, p.kind]))
@@ -478,6 +505,7 @@ export async function switchConversation(id: string, force = false) {
      state.pendingApprovals = []
    }
  }
+  return 'ok'
 }

 /** 删除会话;若删的是当前活跃会话则清空消息+移除活跃 id 持久化。
@@ -541,13 +569,16 @@ async function deleteConversation(id: string) {
  notifyConversationChanged({ deletedConvId: id })
 }

-/** 会话操作失败气泡的 i18n key(M30 族 rename/archive/pin + G3.4 new/delete + G3.3 switch 瞬态失败) */
+/** 会话操作失败气泡的 i18n key(M30 族 rename/archive/pin + G3.4 new/delete + G3.3 switch 瞬态失败
+ *  + convDeleted 关联会话跳转命中已删会话) */
 type ConvOpFailKey =
  | 'renameConvFail' | 'archiveConvFail' | 'pinConvFail'
  | 'newConvFail' | 'deleteConvFail' | 'switchConvFail'
+  | 'convDeleted'

 /** UX走查 P2-7:rename/archive/pin 失败的侧栏就近通知(发布-订阅)。每次失败发布新对象,
- *  ConversationSidebar watch 到即弹 toast;本模块不感知展示细节(翻译/计时归订阅方)。 */
+ *  ConversationSidebar watch 到即弹 toast;本模块不感知展示细节(翻译/计时归订阅方)。
+ *  convDeleted(P3-7/P1-1 分离窗路径)也走此通道:反馈须落在承接会话的窗口内。 */
 export const convOpFailNotice = ref<{
  key: ConvOpFailKey
  params?: Record<string, string | number>
@@ -657,17 +688,33 @@ function toggleSidebar() {
 }

 /** 跨视图跳转会话(S4 TaskDrawer「关联会话」入口):AI 无路由,跳转 = 面板展开 + 切会话。
- * 主窗口面板未展开时先展开再切换;detached(分离窗口)下主窗口无面板,只切会话不动面板。 */
-async function openConversation(id: string) {
+ * 主窗口面板未展开时先展开再切换;detached(分离窗口)下主窗口无面板,emit 跨窗事件由
+ * 分离窗切会话并聚焦(UX走查 P1-1:原实现只切主窗内存态,分离窗不跟随不聚焦,感知「点了没反应」)。
+ * 跳转属程序化导航:命中已删会话不静默新建(P3-7),返回 'not_found' 由调用方就地反馈;
+ * detached 路径的实际切换结果落在分离窗,本窗一律返回 'ok'。 */
+async function openConversation(id: string): Promise<'ok' | 'not_found'> {
+  if (state.detached) {
+    await emitDetachedOpenConversation(id)
+    return 'ok'
+  }
  // 已展开不重复写 persistUiState(省一次 debounced SQLite 写)
-  if (!state.detached && !state.panelOpen) {
+  if (!state.panelOpen) {
    state.panelOpen = true
    persistUiState()
  }
-  await switchConversation(id)
+  return switchConversation(id, false, { noCreateFallback: true })
+}
+
+/** 分离窗消费跨窗切会话事件(P1-1):本地切会话;命中已删会话经 convOpFailNotice 由本窗
+ *  侧栏弹 toast(事件发起方在主窗口,反馈必须落在承接会话的分离窗内)。 */
+async function handleDetachedOpenConversation(convId: string) {
+  const res = await switchConversation(convId, false, { noCreateFallback: true })
+  if (res === 'not_found') convOpFailNotice.value = { key: 'convDeleted' }
 }

 export function useAiConversations() {
+  // 跨窗切会话监听注册(幂等;label 非分离窗不实际挂 listener,主窗口为事件发起方)
+  registerDetachedOpenConvListener(handleDetachedOpenConversation)
  return {
    loadConversations,
    scheduleConversationsRefresh,
@@ -12,6 +12,7 @@
 //! useAiEvents() 返回 shape 保持不变(stores/ai.ts spread 形状不变 → 组件零改动)。

 import { listen, emit } from '@tauri-apps/api/event'
+import { t } from '@/i18n/i18n-helpers'
 import { aiApi } from '@/api'
 import { useAppSettingsStore } from '@/stores/appSettings'
 import { state } from '@/stores/ai'
@@ -19,9 +20,11 @@ import { nextMsgId, setConvState, convStates, switchingConvs, getConvStreamState
 import { resetStreamWatchdog, clearAllStreamWatchdogs, clearResumeAttempts } from './useAiStream'
 import { setStreaming } from './streamingGuard'
 import { scheduleConversationsRefresh } from './useAiConversations'
+import { pendingTaskParked, pendingTaskProgress } from './useAiPendingState'
+import { clearConvBoundaryCache } from './useTaskBoundary'
 import { handleStreamingEvent } from './useAiStreamingEvents'
 import { handleToolEvent } from './useAiToolEvents'
-import { handleLifecycleEvent } from './useAiLifecycleEvents'
+import { handleLifecycleEvent, recordTaskParked } from './useAiLifecycleEvents'
 import type { AiChatEvent, MessageId } from '@/api/types'

 // 跨域共享 helper re-export(原为 useAiEvents 导出,拆分后从 aiShared/叶子透传,消费方 import 路径不变)
@@ -40,9 +43,12 @@ let _startPromise: Promise<void> | null = null

 const appSettings = useAppSettingsStore()

-// 看门狗不重置的事件集合(审批等待/完成/错误/达 max/路径授权/求助由各自 case 内 clear)。
+// 看门狗不重置的事件集合(审批等待/完成/错误/达 max/路径授权/求助/停靠由各自 case 内 clear)。
 // 模块级 Set 复用,避免每事件(delta/token 高频)新建数组字面量做 includes。
-const NO_RESET_WATCHDOG = new Set<AiChatEvent['type']>(['AiApprovalRequired', 'AiCompleted', 'AiError', 'AiMaxRoundsReached', 'AiDirAuthRequired', 'AiHelpRequired'])
+const NO_RESET_WATCHDOG = new Set<AiChatEvent['type']>(['AiApprovalRequired', 'AiCompleted', 'AiError', 'AiMaxRoundsReached', 'AiDirAuthRequired', 'AiHelpRequired', 'AiTaskParked'])
+
+// 后台会话完成 toast 的摘要截长(轻提醒只够判断「做完了/值不值得切回去看」)
+const AGENT_FINISHED_TOAST_SUMMARY_MAX = 40

 /** 全局审批类事件:跨会话放行,不因非当前会话被过滤。审批挂起是等用户决策的跨会话资产,
 *  丢弃后用户在切回该会话前没有任何感知与处理入口;归口仍按 conversation_id 写 per-conv
@@ -73,6 +79,8 @@ function handleAgentFinishedEvent(event: AiChatEvent): boolean {
    status: AgentFinishedStatus
    rounds: number
    tokens: number
+    rejected_tools?: string[] | null
+    stop_kind?: string | null
  }
  const convId = event.conversation_id
  if (!convId || !ev.agent_id) return true
@@ -82,13 +90,73 @@ function handleAgentFinishedEvent(event: AiChatEvent): boolean {
    status: ev.status,
    rounds: ev.rounds,
    tokens: ev.tokens,
+    // 后端 Option→null/缺省,卡片语义统一为缺省=零拒绝
+    rejected_tools: ev.rejected_tools ?? undefined,
+    // 结构化终止原因(可选,旧后端不发):存卡供卡面状态词优先消费,替代 summary 启发式
+    stop_kind: ev.stop_kind ?? undefined,
  })
+  // P3-6:后台会话完成轻提醒(当前会话卡已在消息流可见,不弹)。
+  // composable 无组件上下文,复用 ai-toast 事件总线先例(ai-tool-slow-toast),AiChat listen 弹本地 toast;
+  // 多个子代理连发时 toast 单槽自然合并,无风暴面。
+  if (convId !== state.activeConversationId) {
+    // 未知 status 兜底按 completed 语气(防 t 回显键名);failed 用 warning 色与完成区分
+    const statusKey = ev.status === 'failed' ? 'failed' : ev.status === 'truncated' ? 'truncated' : 'completed'
+    const collapsed = ev.summary.replace(/\s+/g, ' ').trim()
+    const summary = collapsed.length > AGENT_FINISHED_TOAST_SUMMARY_MAX
+      ? collapsed.slice(0, AGENT_FINISHED_TOAST_SUMMARY_MAX) + '…'
+      : collapsed
+    void emit('ai-toast', {
+      msg: t('ai.agentFinishedToast', { status: t(`ai.agentFinished.${statusKey}`), summary }),
+      type: ev.status === 'failed' ? 'warning' : 'info',
+    })
+  }
  // 子代理执行是该会话的真实活跃信号(父 loop 在 spawn_agent 内等待):此前该事件穿透到
  // 活跃事件分支会重置看门狗,现提前归集后显式补上,保持既有不误判停滞的语义。
  resetStreamWatchdog(convId)
  return true
 }

+/** 无人值守停靠域:消费 AiTaskParked(per-conv 落卡 + 后台会话收敛,挂起家族终局)。
+ *  返回 true=已处理。仅拦截后台会话:当前会话放行到 lifecycle 域统一收尾(看门狗/流式复位
+ *  在 cleanupTerminatedConversation,后台分支此处的收敛集合与其对齐但不重复触发两次)。
+ *  停靠卡必须 per-conv 落卡:多会话并发各自可停靠,后台会话的卡丢了用户切回前无从得知。 */
+function handleTaskParkedEvent(event: AiChatEvent): boolean {
+  if (event.type !== 'AiTaskParked') return false
+  const convId = event.conversation_id || state.activeConversationId
+  if (convId && convId !== state.activeConversationId) {
+    recordTaskParked(convId, event.reason, event.stop_kind ?? undefined)
+    // 对齐 AiCompleted 家族后台分支的收敛:删状态项回不在生成、清 per-conv 流式态/去重记录/
+    // 挂起审批集合/自动续跑计数/进度快照,再刷新侧栏(防抖调度)
+    convStates.delete(convId)
+    clearConvStreamState(convId)
+    clearLastDelta(convId)
+    discardConvPendingApprovals(convId)
+    clearResumeAttempts(convId || undefined)
+    pendingTaskProgress.delete(convId)
+    scheduleConversationsRefresh()
+    return true
+  }
+  return false
+}
+
+/** 无人值守进度域:消费 AiTaskProgress(per-conv 快照,静默期「在干活」可见)。
+ *  返回 true=已处理。isCurrent 守卫之前归集(同停靠卡范式):后台会话的进度也要落 Map,
+ *  切回仍可见。进度事件即活体信号,顺带 resetStreamWatchdog(子代理长跑/重入退避期间
+ *  后端心跳之外的第二重存活证明,防看门狗误判停滞)。 */
+function handleTaskProgressEvent(event: AiChatEvent): boolean {
+  if (event.type !== 'AiTaskProgress') return false
+  const convId = event.conversation_id || state.activeConversationId
+  if (!convId) return true
+  pendingTaskProgress.set(convId, {
+    round: event.round,
+    maxRounds: event.max_rounds,
+    tokensUsed: event.tokens_used,
+    updatedAt: Date.now(),
+  })
+  resetStreamWatchdog(convId)
+  return true
+}
+
 /** 跨端用户消息域:miniapp→桌面 user 气泡同步(仅处理 AiUserMessage)。
 *  去重:末条已是同 content 的 user 则跳过(防本地乐观 push + 事件回灌双气泡)。 */
 function handleUserMessageEvent(event: AiChatEvent): boolean {
@@ -128,6 +196,10 @@ export function handleEvent(event: AiChatEvent) {
  if (handleUserMessageEvent(event)) return
  // S1 子代理完成卡归集:在 isCurrent 守卫之前处理(per-conv 落卡,后台会话不丢卡)
  if (handleAgentFinishedEvent(event)) return
+  // 无人值守停靠卡归集:在 isCurrent 守卫之前处理(per-conv 落卡,后台会话不丢卡)
+  if (handleTaskParkedEvent(event)) return
+  // 无人值守进度快照归集:在 isCurrent 守卫之前处理(per-conv 落 Map,后台会话不丢进度)
+  if (handleTaskProgressEvent(event)) return
  // 事件不属于当前展示对话(生成中切走了)→ 不污染当前视图,仅完成/错误/求助时刷新侧边栏;
  // 全局审批类事件例外(isGlobalApprovalEvent),放行到下方按域分派
  const isCurrent = !convId || convId === state.activeConversationId
@@ -145,6 +217,8 @@ export function handleEvent(event: AiChatEvent) {
      clearLastDelta(convId || '')
      discardConvPendingApprovals(convId || '')
      clearResumeAttempts(convId || undefined)
+      // 终态即清进度快照(事件即逝态,会话已终止不留陈旧「进行中」)
+      pendingTaskProgress.delete(convId || '')
      // FE1:后台会话终止只刷新列表(防抖调度,避免与 AiCompleted 收尾的 notify 双拉)。
      scheduleConversationsRefresh()
      // 后台会话终止也触发队列续发/清队(完成续发;错误清该会话队列)
@@ -168,8 +242,10 @@ export function handleEvent(event: AiChatEvent) {
  // 无目标会话(事件缺 convId 且当前无活跃会话):流式 delta 无处累积,跳过写防 null 键无意义写入
  if (!convId && !state.activeConversationId && event.type === 'AiTextDelta') return
  // 活跃事件(delta/工具/新轮/审批结果)到达即标记该会话生成中(enum 兜底写入口;
-  // 后端 AiConvStateChanged{generating} 已先到时同值 set 幂等覆盖,无副作用)
-  if (convId && event.type !== 'AiCompleted' && event.type !== 'AiError' && event.type !== 'AiHelpRequired') {
+  // 后端 AiConvStateChanged{generating} 已先到时同值 set 幂等覆盖,无副作用)。
+  // 终态家族(AiCompleted/AiError/AiHelpRequired/AiTaskParked)除外:标记生成中会与
+  // 收尾的删项收敛打架(停靠后端已复位 generating,不能被兜底写回)
+  if (convId && event.type !== 'AiCompleted' && event.type !== 'AiError' && event.type !== 'AiHelpRequired' && event.type !== 'AiTaskParked') {
    setConvState(convId, 'generating')
  }
  // 流式看门狗:活跃事件重置;审批等待/完成/错误在 case 内 clear(per-conv,各会话独立计时)
@@ -206,6 +282,10 @@ export async function startListener() {
        // S1:会话删除连带清其完成卡(Map 不持已删会话条目;存在即清,不限当前视图)
        if (deleted) {
          clearConvAgentFinished(deleted)
+          // 无人值守三件随会话同亡:停靠卡挂起 + 进度快照 + 边界镜像(边界生命周期=会话存续,设计 §二)
+          pendingTaskParked.delete(deleted)
+          pendingTaskProgress.delete(deleted)
+          clearConvBoundaryCache(deleted)
        }
      })
      _unlistenApprovalClear = await listen('ai-approval-clear-timers', () => { clearAllApprovalTimers() })
@@ -1,6 +1,6 @@
 //! 生命周期事件域 — handleLifecycleEvent + cleanupTerminatedConversation
 //!
-//! 处理:AiCompleted / AiError / AiHelpRequired + 上下文生命周期事件(AiCompressing/
+//! 处理:AiCompleted / AiError / AiHelpRequired / AiTaskParked + 上下文生命周期事件(AiCompressing/
 //! AiManualCompressed/AiAutoCompressed/AiContextCleared)。
 //! 依赖方向:本模块 → aiShared / useAiPendingState(叶子)/ useAiStream / streamingGuard /
 //! useAiConversations,不导入任何同级子 composable。
@@ -10,7 +10,7 @@ import { useAppSettingsStore } from '@/stores/appSettings'
 import { state } from '@/stores/ai'
 import { t } from '@/i18n/i18n-helpers'
 import { nextMsgId, convStates, clearApprovalTimer, flushCurrentText, clearAllToolSlowTimers, friendlyError, notifyConversationChanged, clearLastDelta, discardConvPendingApprovals, notifyQueueCleared } from './aiShared'
-import { clearTextIdleTimer, pendingMaxRounds, pendingHelp, pendingDirAuths } from './useAiPendingState'
+import { clearTextIdleTimer, pendingMaxRounds, pendingHelp, pendingDirAuths, pendingTaskParked, pendingTaskProgress } from './useAiPendingState'
 import { clearStreamWatchdog, clearResumeAttempts } from './useAiStream'
 import { setStreaming } from './streamingGuard'
 import type { AiChatEvent, AiMessage, MessageId } from '@/api/types'
@@ -43,14 +43,16 @@ function isShowTokenUsage(): boolean {
 }

 /**
- * 公共会话终止收尾(AiCompleted/AiError/AiHelpRequired 共用):清看门狗/计时器/流式态/挂起。
+ * 公共会话终止收尾(AiCompleted/AiError/AiHelpRequired/AiTaskParked 共用):清看门狗/计时器/流式态/挂起。
 *
 * 语义差异(调用方自行处理):
 * - AiCompleted: 调用后追加 incomplete 气泡 / token 用量 / 队列 drain
 * - AiError:    调用后追加错误气泡 + 清 queue
 * - AiHelpRequired: 调用后翻 pendingHelp 驱动求助卡
+ * - AiTaskParked: 调用后登记 pendingTaskParked 驱动停靠卡(摘旧卡;不清 pendingHelp,
+ *   熔断并存场景见下方 pendingHelp 分支注释)
 */
-function cleanupTerminatedConversation(convId: string, reason: 'AiCompleted' | 'AiError' | 'AiHelpRequired') {
+function cleanupTerminatedConversation(convId: string, reason: 'AiCompleted' | 'AiError' | 'AiHelpRequired' | 'AiTaskParked') {
  clearStreamWatchdog(convId || undefined)
  // 正常收尾路径清该会话的 delta 去重记录:flushCurrentText 只清活跃会话的,这里按 convId
  // 显式清一遍兜住 convId 与 active 不一致或事件缺 convId 的时序,防残留记录误丢下轮同内容 delta
@@ -83,8 +85,16 @@ function cleanupTerminatedConversation(convId: string, reason: 'AiCompleted' | '
    pendingMaxRounds.value = null
  }
  if (pendingHelp.value && pendingHelp.value.conversationId === convId) {
-    pendingHelp.value = null
+    // 熔断场景后端并存发求助卡+停靠卡(agentic/mod.rs 熔断分支先 emit 求助卡再「补发」
+    // AiTaskParked,注释自称并存意图):停靠收尾不清求助卡,help options 三选项不丢,
+    // 两卡并存供用户任选入口。其余终态(AiCompleted/AiError/AiHelpRequired)照旧清。
+    if (reason !== 'AiTaskParked') pendingHelp.value = null
  }
+  // 无人值守停靠卡:会话有任何终态(含停靠本身)即摘旧卡;停靠 case 在收尾后重新登记,
+  // 其余终态(AiCompleted/AiError,点继续续跑后的正常收敛/出错)摘卡即消失,语义对齐 pendingHelp
+  pendingTaskParked.delete(convId)
+  // 无人值守进度快照:终态即清(事件即逝态,终止后不留陈旧「进行中」;下次 loop 每 5 轮重建)
+  pendingTaskProgress.delete(convId)
  // 路径授权挂起仅清本 conv(终止只清本会话弹窗,不连累并发会话;无归属旧项保守保留)
  pendingDirAuths.value = pendingDirAuths.value.filter(p => !p.conversationId || p.conversationId !== convId)
  // 审批收尾仅清目标 conv 的待审批项 + 对称清其超时计时器(其他会话的审批卡/计时器不受影响;
@@ -104,6 +114,21 @@ function cleanupTerminatedConversation(convId: string, reason: 'AiCompleted' | '
  localStorage.removeItem('df-ai-text')
 }

+/**
+ * 登记无人值守停靠卡(幂等,convId 键控覆盖)。lifecycle 主路径与 useAiEvents 后台会话
+ * 分支共用唯一写入口,防止两处字段口径漂移。convId 缺失兜底当前活跃会话(优于丢卡)。
+ */
+export function recordTaskParked(convId: string | null | undefined, reason: string, stopKind?: string): void {
+  const id = convId || state.activeConversationId
+  if (!id) return
+  pendingTaskParked.set(id, {
+    reason,
+    stopKind: stopKind || undefined,
+    conversationId: id,
+    parkedAt: Date.now(),
+  })
+}
+
 /** lifecycle 域:整轮收尾(AiCompleted)与异常中断(AiError)。返回 true=已处理。 */
 export function handleLifecycleEvent(event: AiChatEvent): boolean {
  switch (event.type) {
@@ -215,6 +240,18 @@ export function handleLifecycleEvent(event: AiChatEvent): boolean {
      return true
    }

+    case 'AiTaskParked': {
+      // 无人值守安全停靠(设计 §四):五路非正常终局统一出口,后端已保存现场并复位
+      // generating(guard 复位非死等)。对齐 AiHelpRequired 家族:终止态收尾不建错误气泡,
+      // 改登记 pendingTaskParked 驱动停靠卡(reason + stop_kind 标签 + 继续/停止归档)。
+      // 队列不动:停靠等用户拍板,排队消息不自动续发不静默清(继续/停止由用户决定)。
+      cleanupTerminatedConversation(event.conversation_id || '', 'AiTaskParked')
+      recordTaskParked(event.conversation_id, event.reason, event.stop_kind ?? undefined)
+      // FE1:停靠刷新侧栏(更新活跃时间排序),由 listener 防抖调度统一收口。
+      notifyConversationChanged()
+      return true
+    }
+
    case 'AiCompressing':
      _contextCallbacks.onCompressing?.()
      return true
@@ -5,7 +5,7 @@
 //! useAiEvents 拆分后,streaming/tool/lifecycle 三域与组件(ChatInput/MaxRoundsCard/
 //! DirAuthDialog/HelpRequiredCard)统一从这里取这些跨域信号。

-import { ref } from 'vue'
+import { reactive, ref } from 'vue'
 import { useAppSettingsStore } from '@/stores/appSettings'

 const appSettings = useAppSettingsStore()
@@ -75,3 +75,29 @@ export interface PendingHelp {
  conversationId: string | null
 }
 export const pendingHelp = ref<PendingHelp | null>(null)
+
+// 无人值守停靠挂起(后端 AiTaskParked 置):convId 键控 Map 而非单 ref。
+// 与 pendingHelp 单 ref 的差异原因:停靠是无人值守长任务的常态终局,多会话并发下
+// 多个会话可各自停靠,单 ref 后到覆盖先到会丢卡(待审批 pendingDirAuths 同款教训)。
+// 消费方(TaskParkedCard)按 activeConversationId 取卡,per-conversation 归位不串台。
+// 幂等:同会话重复停靠按键覆盖(后端单出口单发,覆盖仅防监听重放双卡)。
+export interface PendingTaskParked {
+  reason: string
+  /** 后端结构化停止原因(词表 approval_timeout/cancelled/circuit_breaker/stall_breaker/max_rounds/fatal/midstream);旧后端不发为 undefined */
+  stopKind?: string
+  conversationId: string
+  parkedAt: number
+}
+export const pendingTaskParked = reactive(new Map<string, PendingTaskParked>())
+
+// 无人值守进度快照(后端 AiTaskProgress 每 5 轮置,设计 §4.3):convId 键控 Map(停靠卡同范式,
+// 多会话并发各自有进度互不覆盖)。只存最近一次快照(事件即逝,后端不落库);消费方(TopBar
+// 进度条)按 activeConversationId 取,静默期(子代理长跑/重入退避)凭最后快照可见「在干活」。
+// 终局(AiCompleted/AiError/AiHelpRequired/AiTaskParked)与会话删除时清理。maxRounds=0=不限轮次。
+export interface PendingTaskProgress {
+  round: number
+  maxRounds: number
+  tokensUsed: number
+  updatedAt: number
+}
+export const pendingTaskProgress = reactive(new Map<string, PendingTaskProgress>())
@@ -0,0 +1,61 @@
+//! 无人值守任务边界(per-conv 边界缓存 + IPC 读写)
+//!
+//! 后端真相源是 per_conv.boundary 内存态 + boundary_json 落库快照(ai_task_boundary_get/set)。
+//! 前端这里维护一份只读镜像 Map,服务两个消费面:
+//! - ConversationSidebar 徽标:批量 IPC 不在契约内,镜像按「访问过/设置过」渐进填充
+//!   (切会话时配置卡拉取、设置卡写入),未访问会话不显徽标属已接受取舍;
+//! - TaskBoundaryCard 回显:打开卡/切会话时读镜像,miss 时拉一次。
+//!
+//! 叶子定位:仅依赖 vue + api 层,不导入任何 composable,无环风险。
+
+import { reactive } from 'vue'
+import { aiApi } from '@/api'
+import type { TaskBoundary } from '@/api/types'
+
+/** convId → 当前边界镜像(无键=无边界或未拉取)。后端 set/get 单发,前端不做节流 */
+export const convBoundaries = reactive(new Map<string, TaskBoundary>())
+
+/** 拉取失败会话集合(镜像 miss 的两种语义须区分:确认无边界 vs 拉取失败。
+ *  失败态配置卡禁「一次授权」,防默认空表单静默覆盖库中原授权) */
+export const convBoundaryFetchFailed = reactive(new Set<string>())
+
+/** 某会话边界最近一次拉取是否失败(失败态镜像内容不可信) */
+export function isConvBoundaryFetchFailed(convId: string | null | undefined): boolean {
+  if (!convId) return false
+  return convBoundaryFetchFailed.has(convId)
+}
+
+/** 读某会话边界镜像;无记录返回 null */
+export function getConvBoundary(convId: string | null | undefined): TaskBoundary | null {
+  if (!convId) return null
+  return convBoundaries.get(convId) ?? null
+}
+
+/** 拉取某会话边界并刷新镜像(切会话/打开配置卡时调)。侧栏徽标消费侧保持静默降级;
+ *  配置卡经 isConvBoundaryFetchFailed 读取失败态(成功即清标记,失败置标记) */
+export async function fetchConvBoundary(convId: string | null | undefined): Promise<void> {
+  if (!convId) return
+  try {
+    const b = await aiApi.getTaskBoundary(convId)
+    convBoundaryFetchFailed.delete(convId)
+    if (b) convBoundaries.set(convId, b)
+    else convBoundaries.delete(convId)
+  } catch (e) {
+    convBoundaryFetchFailed.add(convId)
+    console.warn('[TaskBoundary] 读取边界失败(徽标静默降级,配置卡显失败态):', convId, e)
+  }
+}
+
+/** 写入某会话边界(boundary 传 null 清除),IPC 成功后才更新镜像(失败不撒谎) */
+export async function saveConvBoundary(convId: string | null | undefined, boundary: TaskBoundary | null): Promise<void> {
+  if (!convId) return
+  await aiApi.setTaskBoundary(convId, boundary)
+  if (boundary) convBoundaries.set(convId, boundary)
+  else convBoundaries.delete(convId)
+}
+
+/** 清某会话镜像(会话删除时调,防 Map 持已删会话条目) */
+export function clearConvBoundaryCache(convId: string | null | undefined): void {
+  if (!convId) return
+  convBoundaries.delete(convId)
+}
@@ -49,6 +49,8 @@ export default {
    // conversation load/switch failure feedback (network jitter/IPC down → empty list/blank, was silent)
    loadConvFail: 'Failed to load conversations. Please check your network or backend connection.',
    switchConvFail: 'Failed to switch conversation. Please retry.',
+    // UX走查 P3-7/P1-1: linked-conversation jump hit a deleted conversation (was silently creating a blank one / dead click in detached window)
+    convDeleted: 'Conversation deleted',
    // M30: rename/archive/pin IPC failure feedback (was no try/catch, exceptions leaked to unhandledrejection)
    renameConvFail: 'Failed to rename. Please retry.',
    archiveConvFail: 'Failed to {action}. Please retry.',
@@ -87,11 +89,23 @@ export default {
      title: 'Sub-agent',
      completed: 'completed',
      truncated: 'truncated',
+      cancelled: 'cancelled',
      failed: 'failed',
+      // stop_kind structured stop reasons (replaces summary heuristics; truncation sub-kinds surfaced)
+      truncMaxRounds: 'max rounds reached',
+      truncWallClock: 'timed out',
+      truncTokenBudget: 'token budget reached',
+      noReport: 'no report produced',
+      // Rejected-tools chip ({tools} = "tool×count" items, first 2 shown then +N)
+      rejected: 'rejected {tools}',
+      // Startup-failed sub-agents have no persisted trace; card is click-disabled
+      noTrace: 'No trace (failed to start)',
      meta: '{rounds} rounds · {tokens} tokens',
      // S3: finished card is clickable to open the read-only trace (hover hint)
      viewHint: 'Click to view execution trace',
    },
+    // P3-6 background-conversation sub-agent finished light toast ({status} reuses agentFinished status words above, {summary} truncated to 40 chars)
+    agentFinishedToast: 'Sub-agent {status}: {summary}',
    // S3 sub-agent trace overlay (opened from the finished card, read-only simple render,
    // discarded on close)
    agentTrace: {
@@ -102,6 +116,71 @@ export default {
      roleAssistant: 'Assistant',
      roleTool: 'Tool result',
      roleSystem: 'System',
+      deniedTool: 'Denied: {tool}',
+      riskLow: 'low risk',
+      riskMedium: 'medium risk',
+      riskHigh: 'high risk',
+    },
+    // Unattended task parked card (AiTaskParked, terminal of the pending family):
+    // Continue re-authorizes the loop, Stop archives without resuming
+    taskParked: {
+      title: 'Task parked',
+      // stop_kind structured stop reason (vocabulary pinned by backend contract; unknown values fall back to unknownKind)
+      stopKind: {
+        approval_timeout: 'Approval timed out',
+        cancelled: 'Cancelled',
+        circuit_breaker: 'Circuit breaker',
+        stall_breaker: 'Stall breaker',
+        max_rounds: 'Max rounds reached',
+        fatal: 'Repeated failures (retry budget exhausted)',
+        midstream: 'Stream interrupted',
+      },
+      unknownKind: 'Parked',
+      stopArchive: 'Stop & Archive',
+      stoppedToast: 'Task stopped, will not resume',
+      archiveFailed: 'Stop failed: {msg}',
+    },
+    // Unattended task progress (AiTaskProgress, design §4.3): TopBar lightweight progress,
+    // visible as "still working" during silent periods
+    taskProgress: {
+      running: 'Running · round {round}/{max} · {tokens} tokens',
+      unlimited: 'Running · round {round} · {tokens} tokens',
+      barHint: 'Round {round}/{max}',
+    },
+    // Unattended boundary config card (authorized once at kickoff, effective for the task
+    // lifetime, dies with the conversation)
+    taskBoundary: {
+      toggle: 'Unattended',
+      badge: 'Unattended boundary authorized',
+      riskCeiling: 'Risk ceiling',
+      riskLow: 'Low',
+      riskMedium: 'Medium',
+      dirs: 'Directory allowlist',
+      dirPlaceholder: 'Enter absolute directory path',
+      dirAdd: 'Add',
+      dirEmpty: 'No directories added',
+      forbidDestructive: 'Destructive commands always blocked',
+      budgetToggle: 'Budget (advanced)',
+      budgetRounds: 'Max rounds',
+      budgetTokens: 'Max tokens',
+      budgetWallSecs: 'Wall-clock seconds',
+      budgetHint: 'Leave empty for unlimited',
+      budgetInvalid: 'Budget values must be positive integers',
+      confirmSet: 'Authorize once, no interruptions for the whole task',
+      clearBoundary: 'Clear boundary',
+      setOk: 'Unattended boundary authorized',
+      clearOk: 'Boundary cleared, back to per-action approval',
+      setFail: 'Failed to set boundary: {msg}',
+      lockedGenerating: 'Task is running: only clearing (revoke) is allowed, fields are locked',
+      loadFailed: 'Failed to load boundary; the form below is not trustworthy',
+      retryLoad: 'Retry',
+      dirErrIllegal: 'Path contains illegal characters < > : " | ? *',
+      dirErrRelative: 'Enter an absolute path (e.g. D:\\projects or /home/user)',
+      clearConfirm: 'Clearing the boundary revokes unattended authorization immediately; tool calls in the running task will fall back to per-action approval. Clear?',
+      echoRisk: 'risk ceiling {risk}',
+      echoDirs: '{n} dirs',
+      echoBudget: 'budget {rounds} rounds / {tokens} tokens / {secs}s',
+      echoNoBudget: 'no budget limit',
    },
  },
 }
@@ -110,6 +110,7 @@ export default {

    // ── Skill ──
    clearSkill: 'Clear skill',
+    skillBadgeTip: 'Injected full skill playbook: {name}',
    placeholderWithSkill: 'Skill selected. Type arguments and press Enter',
    placeholderDefault: "Type a message... (/ for skills, {'@'} to mention)",
    skillNoMatch: 'No matching skill',
@@ -141,6 +142,8 @@ export default {
    imageTooLarge: 'Image too large (max 10MB), skipped',
    imageLimit: 'Up to {n} images, extras ignored',
    imageReadFailed: 'Failed to read image',
+    imageIgnoredWarn: 'Current model does not support images; they will be ignored on send',
+    imageOnlyBlocked: 'Current model does not support images; switch to a vision model or add some text',

    // ── Confirm dialog ──
    confirmDeleteConversation: 'Delete chat "{title}"? This cannot be undone.',
@@ -49,6 +49,8 @@ export default {
    // 对话加载/切换失败反馈(网络抖动/IPC 断开 → 列表空/切换空白,原静默无反馈)
    loadConvFail: '对话列表加载失败,请检查网络或后端连接',
    switchConvFail: '对话切换失败,请重试',
+    // UX走查 P3-7/P1-1: 关联会话跳转命中已删会话(原静默新建空会话/分离窗死点击)
+    convDeleted: '会话已删除',
    // M30:重命名/归档/置顶 IPC 失败反馈(原无 try/catch 异常进 unhandledrejection,用户无感)
    renameConvFail: '重命名失败,请重试',
    archiveConvFail: '{action}失败,请重试',
@@ -86,11 +88,23 @@ export default {
      title: '子代理',
      completed: '已完成',
      truncated: '已截断',
+      cancelled: '已取消',
      failed: '失败',
+      // stop_kind 结构化终止原因细分(根治 summary 启发式;截断三态各自透出)
+      truncMaxRounds: '已达轮次上限',
+      truncWallClock: '超时截断',
+      truncTokenBudget: 'token 预算截断',
+      noReport: '未产出报告',
+      // 被拒工具 chip({tools} 为「工具名×次数」枚举,多枚前 2 枚 + N)
+      rejected: '被拒 {tools}',
+      // 启动失败型子代理未落库无轨迹,卡禁点(hover 说明替代 viewHint)
+      noTrace: '无轨迹(启动失败)',
      meta: '{rounds} 轮 · {tokens} tokens',
      // S3:完成卡可点击查看只读轨迹(hover 提示)
      viewHint: '点击查看执行轨迹',
    },
+    // P3-6 后台会话子代理完成轻提醒({status} 复用上方 agentFinished 状态词,{summary} 截前 40 字)
+    agentFinishedToast: '子代理{status}: {summary}',
    // S3 子代理轨迹浮层(完成卡点击展开,只读简版渲染,关即弃)
    agentTrace: {
      title: '子代理执行轨迹',
@@ -100,6 +114,68 @@ export default {
      roleAssistant: '助手',
      roleTool: '工具结果',
      roleSystem: '系统',
+      deniedTool: '被拒:{tool}',
+      riskLow: '低风险',
+      riskMedium: '中风险',
+      riskHigh: '高风险',
+    },
+    // 无人值守安全停靠卡(AiTaskParked,挂起家族终局):继续=重新授权续跑,停止归档=不再续跑
+    taskParked: {
+      title: '任务已停靠',
+      // stop_kind 结构化停止原因(词表后端契约钉死,未知值走 unknownKind 中性兜底)
+      stopKind: {
+        approval_timeout: '审批超时',
+        cancelled: '已取消',
+        circuit_breaker: '熔断保护',
+        stall_breaker: '停滞保护',
+        max_rounds: '已达轮次上限',
+        fatal: '连续失败(重入预算耗尽)',
+        midstream: '响应流中断',
+      },
+      unknownKind: '任务停靠',
+      stopArchive: '停止归档',
+      stoppedToast: '任务已停止,不再续跑',
+      archiveFailed: '停止失败:{msg}',
+    },
+    // 无人值守任务进度(AiTaskProgress,设计 §4.3):TopBar 轻量进度条,静默期可见「在干活」
+    taskProgress: {
+      running: '进行中 · 第 {round}/{max} 轮 · {tokens} tokens',
+      unlimited: '进行中 · 第 {round} 轮 · {tokens} tokens',
+      barHint: '第 {round}/{max} 轮',
+    },
+    // 无人值守边界配置卡(发起时一次授权,存续期生效,随会话同亡)
+    taskBoundary: {
+      toggle: '无人值守',
+      badge: '无人值守边界已授权',
+      riskCeiling: '风险上限',
+      riskLow: '低',
+      riskMedium: '中',
+      dirs: '目录白名单',
+      dirPlaceholder: '输入目录绝对路径',
+      dirAdd: '添加',
+      dirEmpty: '尚未添加目录',
+      forbidDestructive: '破坏性命令恒禁止',
+      budgetToggle: '预算(高级)',
+      budgetRounds: '最大轮次',
+      budgetTokens: '最大 tokens',
+      budgetWallSecs: '挂钟秒数',
+      budgetHint: '留空表示不限',
+      budgetInvalid: '预算需为正整数',
+      confirmSet: '一次授权,任务期内不再打扰',
+      clearBoundary: '清除边界',
+      setOk: '已授权无人值守边界',
+      clearOk: '已清除边界,回到逐次审批',
+      setFail: '边界设置失败:{msg}',
+      lockedGenerating: '任务运行中,仅支持清除边界(收权),字段不可修改',
+      loadFailed: '边界读取失败,当前表单不可信',
+      retryLoad: '重试',
+      dirErrIllegal: '路径含非法字符 < > : " | ? *',
+      dirErrRelative: '请输入绝对路径(如 D:\\projects 或 /home/user)',
+      clearConfirm: '清除边界将立即收回无人值守授权,运行中的任务后续工具调用回到逐次审批。确定清除?',
+      echoRisk: '风险上限 {risk}',
+      echoDirs: '{n} 个目录',
+      echoBudget: '预算 {rounds} 轮 / {tokens} tokens / {secs}s',
+      echoNoBudget: '预算不限',
    },
  },
 }
@@ -110,6 +110,7 @@ export default {

    // ── 技能 ──
    clearSkill: '取消技能',
+    skillBadgeTip: '已注入技能「{name}」的完整规程',
    placeholderWithSkill: '已选技能，输入参数后回车',
    placeholderDefault: "输入消息...（/ 触发技能，{'@'} 引用实体）",
    skillNoMatch: '无匹配技能',
@@ -142,6 +143,8 @@ export default {
    imageTooLarge: '图片过大（上限 10MB），已跳过',
    imageLimit: '最多 {n} 张图片，已忽略多余的',
    imageReadFailed: '图片读取失败',
+    imageIgnoredWarn: '当前模型不支持图片，发送时图片将被忽略',
+    imageOnlyBlocked: '当前模型不支持图片，请改用视觉模型或补充文字说明',

    // ── 确认弹层 ──
    confirmDeleteConversation: '确定删除对话「{title}」？该操作不可恢复。',