dsh-config-manager 0.1.78 → 0.1.79

package/src/client/recovery/RecoveryPanel.tsx

@@ -25,7 +25,7 @@ import type { TranslateNS } from '../client-types.ts'
 import { Badge, Banner, Button, Card, Empty, FoldToggle, IconButton, SectionTitle, Spinner, StatusDot } from '../common/ui.tsx'
 import { DiskUsageCard } from '../environment/maintenance/DiskUsageCard.tsx'
 import { RollbackCard } from './RollbackCard.tsx'
-import { SkeletonList } from '../common/Skeleton.tsx'
+import { SkeletonList, SkeletonTable } from '../common/Skeleton.tsx'
 import { ConfirmDialog } from '../common/ConfirmDialog.tsx'
 import { Modal } from '../common/Modal.tsx'
 import { Icon } from '../common/Icon.tsx'
@@ -76,7 +76,7 @@ import { runStore, type RecoveryStoreSlice } from '../run-store.ts'
 import type { CrashReport, IncidentApi, RescueStatus } from './incident-api.ts'
 import { IncompleteCopiesSection } from './IncompleteCopiesSection.tsx'
 import {
-  isSnapshotTrusted, isVerdictAttention, isVerdictSuccess, toRecoveryPreviewView,
+  isSnapshotTrusted, isVerdictAttention, isVerdictSuccess, recoveryBlockReason, toRecoveryPreviewView,
   toRecoveryView,
   crashAdviceKey,
   crashReasonKey,
@@ -874,7 +874,8 @@ function SessionHealthDialog(props: SessionHealthDialogProps) {
           {phase === 'error' && <Banner kind="error">{error ?? t('common.unknownError')}</Banner>}
 
           {/* 首次扫描（还没有任何结果）：给出进行中反馈 —— 旧实现在这里只留一片空白 */}
-          {phase === 'loading' && response === null && <Spinner label={t('sessions.scanning')} />}
+          {/* 首次扫描：按会话表的形状铺骨架（表格行），扫描结果到货时表格原地长出来 */}
+          {phase === 'loading' && response === null && <SkeletonTable rows={6} label={t('sessions.scanning')} />}
 
           {phase === 'ready' && response !== null && (
             <>
@@ -1486,6 +1487,14 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
   const previewView = state.preview !== null ? toRecoveryPreviewView(state.preview) : null
   /** 真有待处理事项（口径唯一来源 = 纯函数 recovery-view.ts 的 recoveryRequired）：决定副标题与空态 */
   const needsAttention = view?.recoveryRequired === true
+  /**
+   * 选中项是否属于「正在正常执行中」的操作。是 ⇒ 恢复/放弃都不该点：它还在跑，
+   * quarantine 会把在跑的 journal 从 active/ 抽走。据此给出**原因**而不是灰按钮。
+   */
+  const selectedLive = selected !== undefined
+    && (view?.activeOperations.some((op) => op.operationId === selected.operationId) ?? false)
+  /** 选中项「执行恢复」不可用的原因（null = 可用）——见 recovery-view.ts recoveryBlockReason */
+  const selectedBlockReason = selected !== undefined ? recoveryBlockReason(selected) : null
 
   return (
     <div className={css.viewBody}>
@@ -1514,9 +1523,15 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
       )}
 
       {/* —— 状态与待处理事项（先异常、后诊断）：三块诊断卡在下方，缺省只展开磁盘占用 —— */}
-      {/* SAFE MODE / recovery-required 状态提示（正常态不渲染任何横幅——无事项即静默） */}
+      {/* SAFE MODE / recovery-required 状态提示（正常态不渲染任何横幅——无事项即静默）。
+          **文案必须与真实阻断态同源**：recoveryRequired 只是「有待处理事项」，不等于写操作已被
+          暂停（残留锁 / 中断的档案复制都不会让 safeMode.blocked 为 true）。此前这里无条件说
+          「已进入安全模式（会修改配置的操作已暂停）」⇒ 用户看到保护提示，实际上许多写操作照常
+          成功，属于假警报（也让真正被阻断的场景失去可信度）。 */}
       {view?.recoveryRequired === true && (
-        <Banner kind="error">{t('recovery.currentState.safeMode')}</Banner>
+        <Banner kind="error">
+          {view.safeModeBlocked ? t('recovery.currentState.safeMode') : t('recovery.currentState.itemsOnly')}
+        </Banner>
       )}
 
       {state.status === 'loading' && <SkeletonList label={t('recovery.loading')} />}
@@ -1564,6 +1579,26 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
         </Card>
       )}
 
+      {/* 正在正常执行的操作（不是 incident）：给一句「会自行结束」，避免用户以为面板出了故障。
+          这一块存在的理由：此前 autosync push 在跑的 12 秒里，它被当成了待处理事故。 */}
+      {state.status === 'ready' && (view?.activeOperations.length ?? 0) > 0 && (
+        <Card className={css.card}>
+          <div className={css.groupLabel}>{t('recovery.live.title')}</div>
+          <div className={css.hint}>{t('recovery.live.hint')}</div>
+          <div className={css.snapshotList}>
+            {view!.activeOperations.map((op) => (
+              <div key={op.operationId} className={css.snapshotRow}>
+                <span className={css.snapshotRowMain} title={op.operationId}>
+                  <span>{op.operationType}</span>
+                  <span>{new Date(op.startedAt).toLocaleString()}</span>
+                  <span><Badge kind="info">{incidentStateLabel(t, op.state)}</Badge></span>
+                </span>
+              </div>
+            ))}
+          </div>
+        </Card>
+      )}
+
       {state.status === 'ready' && (view?.incidents.length ?? 0) > 0 && (
         <>
           {/* 进行中 recovery run 提示 */}
@@ -1691,13 +1726,25 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
 
               {state.actionError !== null && <Banner kind="error">{state.actionError}</Banner>}
 
+              {/* 「执行恢复」不可用的原因：灰按钮不带解释 = 用户只能盲猜（这正是事故里的体验）。
+                  三种原因互斥且都能被代码逐条证明：操作仍在跑 / 无绑定快照 / 决策为需人工处理。 */}
+              {selectedLive ? (
+                <Banner kind="info">{t('recovery.incident.liveBlocked')}</Banner>
+              ) : state.verifyResult === null && selectedBlockReason !== null ? (
+                <div className={css.hint}>
+                  {selectedBlockReason === 'noSnapshot'
+                    ? t('recovery.incident.blockReason.noSnapshot')
+                    : t('recovery.incident.blockReason.needsAttention')}
+                </div>
+              ) : null}
+
               {/* 动作区 */}
               <div className={css.actionRow}>
                 {state.verifyResult === null && (
                   <>
                     <Button
                       variant="danger"
-                      disabled={state.running || !(previewView?.actionable ?? false)}
+                      disabled={state.running || selectedLive || !(previewView?.actionable ?? false)}
                       loading={state.running}
                       onClick={() => { setConfirmOpen(true) }}
                     >
@@ -1705,7 +1752,7 @@ export function RecoveryPanel(props: RecoveryPanelProps) {
                     </Button>
                     <Button
                       variant="ghost"
-                      disabled={state.running}
+                      disabled={state.running || selectedLive}
                       onClick={() => { setDismissOpen(true) }}
                     >
                       {t('recovery.dismiss')}

package/src/client/recovery/RollbackCard.tsx

@@ -57,6 +57,7 @@ import type {
 } from '../../ui/rollback-view.ts'
 import { redact } from '../../security/redaction.ts'
 import { Badge, Banner, Button, Card, Checkbox, Empty, IconButton, SectionTitle, Spinner } from '../common/ui.tsx'
+import { SkeletonList } from '../common/Skeleton.tsx'
 import { Icon } from '../common/Icon.tsx'
 import { InfoHint } from '../common/InfoHint.tsx'
 import { Modal } from '../common/Modal.tsx'
@@ -460,7 +461,7 @@ export function RollbackCard({ recoveryApi, t }: RollbackCardProps) {
           </>
         )}
 
-        {status === 'loading' && <Spinner label={t('recovery.loading')} />}
+        {status === 'loading' && <SkeletonList count={3} label={t('recovery.loading')} />}
         {status === 'error' && (
           <div className={css.actionRow}>
             <Banner kind="error">{error !== null ? error : t('rollback.apiMissing')}</Banner>
@@ -544,7 +545,7 @@ export function RollbackCard({ recoveryApi, t }: RollbackCardProps) {
             )}
           />
           <Modal.Body scroll>
-            {status === 'loading' && <Spinner label={t('recovery.loading')} />}
+            {status === 'loading' && <SkeletonList count={3} label={t('recovery.loading')} />}
             {status === 'error' && (
               <div className={css.actionRow}>
                 <Banner kind="error">{error !== null ? error : t('rollback.apiMissing')}</Banner>
@@ -829,6 +830,10 @@ export function RollbackCard({ recoveryApi, t }: RollbackCardProps) {
                       {segment.unavailableCount > 0 && (
                         <span>{t('rollback.result.unavailable', { n: segment.unavailableCount })}</span>
                       )}
+                      {segment.unclaimedCount > 0 && (
+                        <span>{t('rollback.result.unclaimed', { n: segment.unclaimedCount })}</span>
+                      )}
+                      {segment.unclaimedPaths.map((line) => <span key={'unclaimed:' + line}>{line}</span>)}
                       {segment.concurrentCount > 0 && (
                         <span>{t('rollback.result.concurrent', { n: segment.concurrentCount })}</span>
                       )}

package/src/client/recovery/RollbackDiffPane.tsx

@@ -12,7 +12,8 @@ import type { TranslateNS } from '../client-types.ts'
 import type { RollbackFileDiffResult } from '../../ui/rollback-view.ts'
 import { rollbackFileDiffComparable, rollbackFileDiffReasonKey } from '../../ui/rollback-view.ts'
 import { redact } from '../../security/redaction.ts'
-import { Banner, Spinner } from '../common/ui.tsx'
+import { Banner } from '../common/ui.tsx'
+import { SkeletonTable } from '../common/Skeleton.tsx'
 import { DiffTable } from '../common/DiffTable.tsx'
 import css from '../config-manager.module.css'
 
@@ -48,7 +49,7 @@ export function RollbackDiffPane({ state, rt, title, fill }: RollbackDiffPanePro
    */
   const shell = (body: ReactNode): ReactNode =>
     fill === true ? <div className={css.diffPane + ' ' + css.diffPaneFill}>{body}</div> : body
-  if (state.status === 'loading') return shell(<Spinner label={rt('rollback.diff.loading')} />)
+  if (state.status === 'loading') return shell(<SkeletonTable rows={8} label={rt('rollback.diff.loading')} />)
   if (state.status === 'error') return shell(<Banner kind="error">{state.message === null ? rt('rollback.diff.failed') : redact(state.message)}</Banner>)
   const diff = state.diff
   if (diff.ok !== true) {

package/src/client/recovery/recovery-locales.ts

@@ -23,7 +23,8 @@ export const zh = {
   'recovery.banner': '配置修改已被保护：存在未完成的恢复事项。请先处理后继续。',
   'recovery.bannerAction': '去处理',
   'recovery.required': '需要恢复',
-  'recovery.requiredHint': '检测到一次操作未正常完成，为安全起见已暂停所有会修改配置的操作。请处理以下恢复事项以恢复正常。',
+  // 「有待处理事项」≠「写操作已被暂停」：后者只有 safeMode.blocked 才成立（横幅文案另有一对键）。
+  'recovery.requiredHint': '存在需要处理的恢复事项（残留锁、未完成的操作或中断的复制）。处理完这些事项即恢复正常。',
   'recovery.rollbackRecommended': '建议回滚',
   'recovery.rollbackContinue': '续跑回滚',
   'recovery.inProgress': '恢复进行中',
@@ -54,6 +55,15 @@ export const zh = {
   // 当前状态
   'recovery.currentState.title': '当前状态',
   'recovery.currentState.safeMode': '已进入安全模式（会修改配置的操作已暂停）',
+  // 有待处理事项、但 safeMode.blocked 为 false（残留锁 / 中断复制 / 旧宿主）：不得声称写操作已被暂停
+  'recovery.currentState.itemsOnly': '存在需要处理的恢复事项（写操作未被暂停）',
+  // 正在正常执行的操作（不是 incident）
+  'recovery.live.title': '正在执行的操作',
+  'recovery.live.hint': '这些操作正在正常执行中，不是未完成的恢复事项；结束后会自动消失。',
+  // 「执行恢复 / 放弃恢复」不可用的原因（灰按钮必须能自证）
+  'recovery.incident.liveBlocked': '该操作仍在进行中，现在不能恢复也不能放弃，请等它结束。',
+  'recovery.incident.blockReason.noSnapshot': '本次操作没有绑定可信恢复快照，因此无法执行恢复。',
+  'recovery.incident.blockReason.needsAttention': '该事项被判定为需要人工处理，无法自动恢复。',
   'recovery.currentState.hasSnapshot': '存在可信恢复快照',
   'recovery.currentState.noSnapshot': '无可信恢复快照',
   // 快照信息
@@ -450,6 +460,7 @@ export const zh = {
   'rollback.result.conflict': '{n} 个文件两侧改到同一处，已保持原样 —— 需要你手工处理',
   'rollback.result.unavailable': '{n} 个文件无法安全撤销（缺少中间版本 / 二进制 / 差异过大），已保持原样',
   'rollback.result.concurrent': '{n} 个文件在回退过程中又被改过，已保持原样',
+  'rollback.result.unclaimed': '{n} 个文件无法判定属于哪个对话（改动时没有任何对话在运行），已保持原样',
   'rollback.result.selectionSkipped': '{n} 个文件按你的勾选跳过了',
   'rollback.preview.files.empty': '工作区与该回退点一致，无需恢复',
   /* —— T15：**预览态**（点「回退」之前那一屏）的四态文案 ——
@@ -634,7 +645,7 @@ export const en: Record<keyof typeof zh, string> = {
   'recovery.banner': 'Configuration changes are protected: there is an unfinished recovery item. Resolve it before continuing.',
   'recovery.bannerAction': 'Go to recovery',
   'recovery.required': 'Recovery Required',
-  'recovery.requiredHint': 'An operation did not complete normally. To stay safe, all config-modifying operations are paused. Handle the recovery item(s) below to restore normal operation.',
+  'recovery.requiredHint': 'Recovery item(s) need handling (a stale lock, an unfinished operation, or an interrupted copy). Resolve them to restore normal operation.',
   'recovery.rollbackRecommended': 'Rollback recommended',
   'recovery.rollbackContinue': 'Continue rollback',
   'recovery.inProgress': 'Recovery in progress',
@@ -661,6 +672,12 @@ export const en: Record<keyof typeof zh, string> = {
   'recovery.verify.verdict.unknown': 'Unknown',
   'recovery.currentState.title': 'Current state',
   'recovery.currentState.safeMode': 'Safe mode active (config-modifying operations paused)',
+  'recovery.currentState.itemsOnly': 'Recovery item(s) need handling (write operations are not paused)',
+  'recovery.live.title': 'Running operations',
+  'recovery.live.hint': 'These operations are running normally; they are not unfinished recovery items and will disappear when they finish.',
+  'recovery.incident.liveBlocked': 'This operation is still running, so it cannot be recovered or dismissed yet. Wait for it to finish.',
+  'recovery.incident.blockReason.noSnapshot': 'This operation has no trusted recovery snapshot bound to it, so recovery cannot run.',
+  'recovery.incident.blockReason.needsAttention': 'This item is classified as needing manual handling and cannot be recovered automatically.',
   'recovery.currentState.hasSnapshot': 'Trusted recovery snapshot available',
   'recovery.currentState.noSnapshot': 'No trusted recovery snapshot',
   'recovery.snapshot.title': 'Recovery snapshot',
@@ -1033,6 +1050,7 @@ export const en: Record<keyof typeof zh, string> = {
   'rollback.result.conflict': '{n} file(s) were changed on both sides in the same place and were left as they are — they need your decision',
   'rollback.result.unavailable': '{n} file(s) could not be reverted safely (no common ancestor / binary / diff too large) and were left as they are',
   'rollback.result.concurrent': '{n} file(s) changed again while this rewind was running and were left as they are',
+  'rollback.result.unclaimed': '{n} file(s) could not be attributed to any conversation (nothing was running when they changed) and were left as they are',
   'rollback.result.selectionSkipped': '{n} file(s) skipped by your selection',
   'rollback.preview.files.empty': 'The workspace already matches this rollback point, nothing to restore',
   'rollback.preview.files.unavailable': 'The workspace state of this rollback point has no usable record (reason: {reason}), nothing to restore',

package/src/client/recovery/recovery-view.test.ts

@@ -9,7 +9,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 
 import {
-  isSnapshotTrusted, isVerdictAttention, isVerdictSuccess, sortIncidentsByNewest,
+  isSnapshotTrusted, isVerdictAttention, isVerdictSuccess, recoveryBlockReason, sortIncidentsByNewest,
   toRecoveryPreviewView, toRecoveryView, verdictToUiState,
 } from './recovery-view.ts';
 import type { RecoveryStatus } from '../../ui/types.ts';
@@ -220,3 +220,41 @@ test('sortIncidentsByNewest：按 createdAt 倒序', () => {
   assert.equal(sorted[0]!.operationId, 'b');
   assert.equal(sorted[1]!.operationId, 'a');
 });
+
+// ---------- 正在正常执行的操作（本轮修复：不再当成「未完成的恢复事项」） ----------
+
+test('toRecoveryView：live[] 映射为 activeOperations，且不改变 state / recoveryRequired', () => {
+  const v = toRecoveryView(mkStatus({
+    live: [{
+      operationId: '00000000-0000-4000-8000-0000000000bb',
+      operationType: 'autosync-push',
+      state: 'APPLYING',
+      startedAt: '2026-01-01T00:00:00.000Z',
+    }],
+  }));
+  assert.equal(v.activeOperations.length, 1);
+  assert.equal(v.activeOperations[0]!.operationType, 'autosync-push');
+  assert.equal(v.activeOperations[0]!.state, 'APPLYING');
+  // 正在跑不是问题：既不进 incidents，也不触发「需要恢复」的横幅
+  assert.deepEqual(v.incidents, []);
+  assert.equal(v.recoveryRequired, false);
+  assert.equal(v.state, 'NORMAL');
+});
+
+test('toRecoveryView：旧宿主不返回 live 字段 → activeOperations 为空数组（不误报正在跑）', () => {
+  const v = toRecoveryView({ incidents: [], running: [] });
+  assert.deepEqual(v.activeOperations, []);
+});
+
+test('recoveryBlockReason：与 actionable 严格互补（面板据此解释「为什么灰」）', () => {
+  // needs-attention 优先：即使有快照，阻塞原因是「需人工处理」而不是「没快照」
+  assert.equal(recoveryBlockReason({ decision: 'needs-attention', snapshotId: 'snap-1' }), 'needsAttention');
+  assert.equal(recoveryBlockReason({ decision: 'needs-attention', snapshotId: null }), 'needsAttention');
+  // 能恢复的决策但没有可信快照 → 无快照可回滚
+  assert.equal(recoveryBlockReason({ decision: 'rollback-recommended', snapshotId: null }), 'noSnapshot');
+  // 判据必须与 actionable 逐字同口径（:108 只认 null / ''），所以这里也只断言这两种形态
+  assert.equal(recoveryBlockReason({ decision: 'rollback-recommended', snapshotId: '' }), 'noSnapshot');
+  // 可执行 → 无阻塞原因
+  assert.equal(recoveryBlockReason({ decision: 'rollback-recommended', snapshotId: 'snap-1' }), null);
+  assert.equal(recoveryBlockReason({ decision: 'rollback-continue', snapshotId: 'snap-1' }), null);
+});

package/src/client/recovery/recovery-view.ts

@@ -20,7 +20,7 @@
  * NEEDS_ATTENTION 显示为 recovered、绝不在 snapshot 不可信时显示可恢复。
  */
 import type {
-  RecoveryDecision, RecoveryIncident, RecoveryPreview, RecoveryStatus, RecoveryVerdict,
+  RecoveryActiveOperation, RecoveryDecision, RecoveryIncident, RecoveryPreview, RecoveryStatus, RecoveryVerdict,
 } from '../../ui/types.ts';
 
 /** UI 顶层状态分类。 */
@@ -71,6 +71,12 @@ export interface RecoveryView {
   incidents: RecoveryIncidentView[];
   /** 进行中的 recovery run（runId + status）。 */
   running: { runId: string; status: string }[];
+  /**
+   * 正在正常执行的操作（不是 incident）。决定两件事：
+   *  ① 面板要给出一句「这些在执行中，会自行结束」，而不是让用户对着灰按钮猜；
+   *  ② 若某条 incident 恰好也在跑（宿主判定放宽/旧宿主），对应行的「执行恢复/放弃恢复」要解释原因。
+   */
+  activeOperations: RecoveryActiveOperation[];
   /** 需用户显式处理的残留锁（attention=true 时才非 null）。 */
   lock: RecoveryLockView | null;
   /**
@@ -128,6 +134,8 @@ export function toRecoveryView(status: RecoveryStatus): RecoveryView {
     recoveryRequired,
     incidents,
     running: status.running,
+    // 旧宿主不返回 live → 空数组（绝不误报「有操作在跑」）
+    activeOperations: status.live ?? [],
     lock,
     safeModeStuck,
     safeModeBlocked,
@@ -136,6 +144,20 @@ export function toRecoveryView(status: RecoveryStatus): RecoveryView {
   };
 }
 
+/**
+ * 「执行恢复」为什么不可用（面板显示原因，而不是丢一个没有任何解释的灰按钮）。
+ *
+ * 判据与 `actionable` 严格互补（同一条规则两处呈现）：decision=needs-attention 断了
+ * 恢复路径，snapshotId 为空断了快照来源。返回 null = 可执行。
+ */
+export function recoveryBlockReason(
+  incident: Pick<RecoveryIncidentView, 'decision' | 'snapshotId'>,
+): 'needsAttention' | 'noSnapshot' | null {
+  if (incident.decision === 'needs-attention') return 'needsAttention';
+  if (incident.snapshotId === null || incident.snapshotId === '') return 'noSnapshot';
+  return null;
+}
+
 /** 单个 preview 的渲染模型。 */
 export interface RecoveryPreviewView {
   operationId: string;

package/src/client/run-store.test.ts

@@ -1617,7 +1617,7 @@ test('P0-9: 持久化字段清单显式化（键集合断言 —— 新增字段
     'loadError', 'pullReport', 'pushPreview', 'pushReport', 'repoUrl', 'webdavUrl', 'webdavUsername',
   ])
   assert.deepEqual(keys(p.sync.byChannel.git), [
-    'autosync', 'autosyncEnabled', 'autosyncInterval', 'encrypt', 'includeSecrets',
+    'autosync', 'autosyncEnabled', 'autosyncInterval', 'autosyncRealtime', 'encrypt', 'includeSecrets',
     'loadingSnapshots', 'selectedSnapshotId', 'sessionsInclude', 'sessionsLimit', 'snapshots',
     'syncMode', 'syncSections',
   ])

package/src/client/run-store.ts

@@ -1023,6 +1023,8 @@ export function toPersistedState(state: StoreState): PersistedState {
     autosync: c.autosync,
     autosyncEnabled: c.autosyncEnabled,
     autosyncInterval: c.autosyncInterval,
+    // 真·自动同步的本地监听开关（用户设置，非敏感；缺省 true）
+    autosyncRealtime: c.autosyncRealtime,
   })
   return {
     v: 1,
@@ -1645,6 +1647,8 @@ export class RunStore {
               autosync: null,
               autosyncEnabled: false,
               autosyncInterval: '30m',
+              // 旧版持久化载荷没有这个字段 → 缺省开启（真·自动同步是缺省行为）
+              autosyncRealtime: true,
             }
           : undefined
         return {

package/src/client/sync/AutosyncCard.tsx

@@ -11,11 +11,12 @@ import { Badge, Card } from '../common/ui.tsx'
 import { Select } from '../common/Select.tsx'
 import { InfoHint } from '../common/InfoHint.tsx'
 import {
-  autosyncIntervalMs, autosyncSkipDetail, autosyncStatusText, computeAutosyncCountdown, formatIntervalDuration,
+  autosyncFailureMessage, autosyncIntervalMs, autosyncSkipDetail, autosyncStatusText, computeAutosyncCountdown,
+  formatIntervalDuration,
 } from './sync-view.ts'
 // 展示文本渲染前统一脱敏（与 ErrorBanner/ReportView 同规矩）
 import { redact } from '../../security/redaction.ts'
-import type { AutosyncInterval } from './sync-api.ts'
+import type { AutosyncAutoApplyTier, AutosyncConflictPolicy, AutosyncInterval } from './sync-api.ts'
 import type { ChannelSyncState } from './sync-view.ts'
 import { autosyncIntervalKey } from '../../ui/sync-settings-view.ts'
 import type { SyncAutosyncIntervalKey } from '../../ui/sync-settings-view.ts'
@@ -33,14 +34,20 @@ function intervalLabel(iv: AutosyncInterval, t: TranslateNS<'config-manager-sync
 /* ------------------------------------------- 拆分出的 render 段（t42，同文件内子组件） */
 
 /** 自动同步设置（当前通道）：总开关 + 间隔下拉 + 状态徽章（文案/倒计时在卡内派生）。 */
-export function AutosyncCard({ t, uiT, settings, busy, onToggleAutosync, onUpdateInterval }: {
+export function AutosyncCard({ t, uiT, settings, busy, onToggleAutosync, onUpdateInterval, onUpdateOptions }: {
   t: TranslateNS<'config-manager-sync'>
   uiT: UiT
   settings: Pick<ChannelSyncState, 'autosync' | 'autosyncEnabled' | 'autosyncInterval'>
   busy: boolean
   onToggleAutosync: (enabled: boolean) => void
   onUpdateInterval: (interval: AutosyncInterval) => void
+  /** 真·自动同步的三个策略项（realtime / 自动应用等级 / 冲突策略）；只传要改的字段 */
+  onUpdateOptions: (patch: { realtime?: boolean; autoApplyTier?: AutosyncAutoApplyTier; conflictPolicy?: AutosyncConflictPolicy }) => void
 }) {
+  // 三件套读自宿主状态（缺省值集中在这里，与宿主 DEFAULT_AUTOSYNC_* 的口径一致）
+  const realtime = settings.autosync?.realtime ?? true
+  const autoApplyTier: AutosyncAutoApplyTier = settings.autosync?.autoApplyTier ?? 'medium'
+  const conflictPolicy: AutosyncConflictPolicy = settings.autosync?.conflictPolicy ?? 'local'
   const autosyncText = settings.autosync !== null ? autosyncStatusText(settings.autosync, uiT) : t('autosync.statusNever')
   /** 距下次自动同步剩余 ms（null = 从未运行；0 = 已到期） */
   const autosyncCountdownMs = settings.autosync !== null && settings.autosync.elapsedMs >= 0
@@ -49,9 +56,10 @@ export function AutosyncCard({ t, uiT, settings, busy, onToggleAutosync, onUpdat
   // issue #79：本轮为什么没同步 / 失败了什么，必须看得见 —— 此前只写进 info 级日志
   // （默认日志级别 warn），界面恒无提示，用户只能去翻 sync-autosync.json。
   const skipDetail = settings.autosync !== null ? autosyncSkipDetail(settings.autosync, t) : null
-  const lastMessage = settings.autosync?.lastRunMessage !== undefined && settings.autosync.lastRunMessage !== ''
-    ? redact(settings.autosync.lastRunMessage)
-    : null
+  // issue #105：只有本轮真的失败才渲染错误原文。此前只看「非空」，于是上一轮（甚至十天前）
+  // 的旧错误会被当成当前结论继续展示；判据现在收在 autosyncFailureMessage 一处。
+  const failureMessage = settings.autosync !== null ? autosyncFailureMessage(settings.autosync) : null
+  const lastMessage = failureMessage === null ? null : redact(failureMessage)
   return (
     <Card>
       <span className={css.groupLabel}>{t('autosync.title')} <InfoHint text={t('autosync.description')} label={t('common.infoHint')} /></span>
@@ -74,6 +82,41 @@ export function AutosyncCard({ t, uiT, settings, busy, onToggleAutosync, onUpdat
           options={AUTOSYNC_INTERVAL_OPTIONS.map((iv) => ({ value: iv, label: intervalLabel(iv, t) }))}
         />
       </label>
+      <label className={css.checkboxRow}>
+        <input
+          type="checkbox"
+          checked={realtime}
+          disabled={busy}
+          onChange={(e: ChangeEvent<HTMLInputElement>) => { onUpdateOptions({ realtime: e.target.checked }) }}
+        />
+        <span>{t('autosync.realtime')} <InfoHint text={t('autosync.realtimeHint')} label={t('common.infoHint')} /></span>
+      </label>
+      <label className={css.field}>
+        <span className={css.fieldLabel}>{t('autosync.autoApplyTier')} <InfoHint text={t('autosync.autoApplyTierHint')} label={t('common.infoHint')} /></span>
+        <Select
+          value={autoApplyTier}
+          disabled={busy}
+          ariaLabel={t('autosync.autoApplyTier')}
+          onChange={(next) => { onUpdateOptions({ autoApplyTier: next as AutosyncAutoApplyTier }) }}
+          options={[
+            { value: 'low', label: t('autosync.tierLow') },
+            { value: 'medium', label: t('autosync.tierMedium') },
+          ]}
+        />
+      </label>
+      <label className={css.field}>
+        <span className={css.fieldLabel}>{t('autosync.conflictPolicy')} <InfoHint text={t('autosync.conflictPolicyHint')} label={t('common.infoHint')} /></span>
+        <Select
+          value={conflictPolicy}
+          disabled={busy}
+          ariaLabel={t('autosync.conflictPolicy')}
+          onChange={(next) => { onUpdateOptions({ conflictPolicy: next as AutosyncConflictPolicy }) }}
+          options={[
+            { value: 'local', label: t('autosync.conflictLocal') },
+            { value: 'ask', label: t('autosync.conflictAsk') },
+          ]}
+        />
+      </label>
       <div className={css.statRow}>
         <Badge kind={settings.autosync?.lastRunStatus === 'failed' ? 'error' : settings.autosync?.lastRunStatus === 'skipped' ? 'warn' : 'info'}>
           {autosyncText}