diff --git a/backend/src/api/oaScheduling.js b/backend/src/api/oaScheduling.js
index 3768458..0ff0ff7 100644
--- a/backend/src/api/oaScheduling.js
+++ b/backend/src/api/oaScheduling.js
@@ -34,6 +34,12 @@ export function getScheduleBoard(params) {
   return request({ url: '/backend/oa/scheduling/board', method: 'get', params })
 }
 
+// 批量按格子编辑排班：cells 为排班板多选的「员工 × 日期」任意组合
+// shift_id>0 设为该班次（有排班=调班，无排班=新增）；shift_id=0 清除（休息/请假）
+export function saveScheduleEntryCells(data) {
+  return request({ url: '/backend/oa/scheduling/entries/save-cells', method: 'post', data })
+}
+
 /* ----------------------------- 排班模板 ----------------------------- */
 
 // 平台预置 + 自定义模板（只读）；租户调用后规则会复制到自己的方案
diff --git a/backend/src/views/apps/oa/scheduling/components/batchDialog.vue b/backend/src/views/apps/oa/scheduling/components/batchDialog.vue
new file mode 100644
index 0000000..f51e1e2
--- /dev/null
+++ b/backend/src/views/apps/oa/scheduling/components/batchDialog.vue
@@ -0,0 +1,180 @@
+<template>
+  <el-dialog
+    v-model="visible"
+    title="批量编辑所选格子"
+    width="420px"
+    append-to-body
+    destroy-on-close
+    @open="handleOpen"
+  >
+    <div class="batch-summary">
+      已选 <b>{{ cells.length }}</b> 个格子（<b>{{ employeeCount }}</b> 人 · <b>{{ dateCount }}</b> 天），
+      选了哪些格子就改哪些格子。
+    </div>
+
+    <el-form label-width="82px" @submit.prevent>
+      <el-form-item label="操作">
+        <el-radio-group v-model="action">
+          <el-radio value="shift">设置班次（上班/调班）</el-radio>
+          <el-radio value="clear">清除排班（休息/请假）</el-radio>
+        </el-radio-group>
+      </el-form-item>
+
+      <el-form-item v-if="action === 'shift'" label="班次">
+        <el-select v-model="shiftId" placeholder="选择班次" style="width: 100%">
+          <el-option
+            v-for="item in shifts"
+            :key="item.id"
+            :value="item.id"
+            :label="optionLabel(item)"
+          >
+            <span class="shift-option">
+              <span class="shift-dot" :style="{ background: item.color }" />
+              <span>{{ optionLabel(item) }}</span>
+            </span>
+          </el-option>
+        </el-select>
+        <div v-if="shiftHint" class="shift-hint">{{ shiftHint }}</div>
+      </el-form-item>
+
+      <el-form-item v-if="action === 'shift'" label="类型">
+        <el-radio-group v-model="source">
+          <el-radio value="temp">临时调整（显示「临」标记）</el-radio>
+          <el-radio value="normal">正常排班（不显示标记）</el-radio>
+        </el-radio-group>
+      </el-form-item>
+
+      <el-form-item label="备注">
+        <el-input
+          v-model="note"
+          :placeholder="action === 'clear' ? '如：请假、休息' : '如：加班支援（可选）'"
+          maxlength="60"
+        />
+      </el-form-item>
+    </el-form>
+
+    <template #footer>
+      <el-button @click="visible = false">取消</el-button>
+      <el-button type="primary" :loading="saving" @click="handleSave">
+        {{ action === 'clear' ? '清除所选' : '应用到所选' }}
+      </el-button>
+    </template>
+  </el-dialog>
+</template>
+
+<script setup>
+import { computed, ref } from 'vue'
+import { ElMessage } from 'element-plus'
+import { getShiftList, saveScheduleEntryCells } from '@/api/oaScheduling'
+
+const props = defineProps({
+  modelValue: Boolean,
+  // 排班板多选的格子：[{ employee_id, employee_name, date }]
+  cells: { type: Array, default: () => [] }
+})
+const emit = defineEmits(['update:modelValue', 'changed'])
+
+const visible = computed({
+  get: () => props.modelValue,
+  set: (val) => emit('update:modelValue', val)
+})
+
+const action = ref('shift')
+const shiftId = ref(null)
+const source = ref('temp')
+const note = ref('')
+const shifts = ref([])
+const saving = ref(false)
+
+const employeeCount = computed(() => new Set(props.cells.map((item) => item.employee_id)).size)
+const dateCount = computed(() => new Set(props.cells.map((item) => item.date)).size)
+
+function optionLabel(item) {
+  const remark = item.remark ? ` · ${item.remark}` : ''
+  return `${item.name}（${item.work_start.slice(0, 5)}-${item.work_end.slice(0, 5)}${remark}）`
+}
+
+const shiftHint = computed(() => {
+  const found = shifts.value.find((item) => item.id === shiftId.value)
+  return found ? `${found.name}：${found.work_start.slice(0, 5)} - ${found.work_end.slice(0, 5)}` : ''
+})
+
+async function handleOpen() {
+  action.value = 'shift'
+  shiftId.value = null
+  source.value = 'temp'
+  note.value = ''
+  if (!shifts.value.length) {
+    const res = await getShiftList()
+    shifts.value = res.data?.list || []
+  }
+  if (shifts.value.length && !shiftId.value) {
+    shiftId.value = shifts.value[0].id
+  }
+}
+
+async function handleSave() {
+  if (!props.cells.length) {
+    ElMessage.warning('没有选中的格子')
+    return
+  }
+  if (action.value === 'shift' && !shiftId.value) {
+    ElMessage.warning('请选择班次')
+    return
+  }
+  saving.value = true
+  try {
+    const res = await saveScheduleEntryCells({
+      cells: props.cells.map((item) => ({ employee_id: item.employee_id, schedule_date: item.date })),
+      shift_id: action.value === 'shift' ? shiftId.value : 0,
+      source: source.value,
+      note: note.value
+    })
+    const stats = res.data || {}
+    const parts = []
+    if (stats.created) parts.push(`新增 ${stats.created}`)
+    if (stats.updated) parts.push(`调整 ${stats.updated}`)
+    if (stats.cleared) parts.push(`清除 ${stats.cleared}`)
+    if (stats.skipped) parts.push(`跳过 ${stats.skipped}`)
+    ElMessage.success(`批量编辑完成：${parts.join('、') || '无变更'}`)
+    visible.value = false
+    emit('changed')
+  } catch (error) {
+    ElMessage.error(error.message || '批量编辑失败')
+  } finally {
+    saving.value = false
+  }
+}
+</script>
+
+<style scoped>
+.batch-summary {
+  padding: 8px 12px;
+  margin-bottom: 14px;
+  border-radius: 6px;
+  background: #ecf5ff;
+  color: #409eff;
+  font-size: 12px;
+  line-height: 20px;
+}
+
+.shift-option {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.shift-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 2px;
+  flex: none;
+}
+
+.shift-hint {
+  font-size: 12px;
+  color: #909399;
+  line-height: 18px;
+  margin-top: 4px;
+}
+</style>
diff --git a/backend/src/views/apps/oa/scheduling/components/planDialog.vue b/backend/src/views/apps/oa/scheduling/components/planDialog.vue
index 735ae80..6153937 100644
--- a/backend/src/views/apps/oa/scheduling/components/planDialog.vue
+++ b/backend/src/views/apps/oa/scheduling/components/planDialog.vue
@@ -2,7 +2,7 @@
   <el-dialog
     :model-value="modelValue"
     title="排班方案"
-    width="980px"
+    width="1020px"
     top="5vh"
     destroy-on-close
     @update:model-value="emit('update:modelValue', $event)"
@@ -27,41 +27,43 @@
       </div>
 
       <el-table :data="plans" v-loading="loading" size="small" max-height="430">
-        <el-table-column prop="plan_name" label="方案名称" min-width="150" show-overflow-tooltip />
-        <el-table-column label="类型" width="80">
+        <el-table-column prop="plan_name" label="方案名称" min-width="130" show-overflow-tooltip />
+        <el-table-column label="类型" width="64">
           <template #default="{ row }">
             <el-tag :type="row.plan_type === 2 ? 'warning' : ''" size="small">
               {{ row.plan_type === 2 ? "临时" : "常规" }}
             </el-tag>
           </template>
         </el-table-column>
-        <el-table-column prop="org_name" label="作用范围" min-width="150" show-overflow-tooltip />
-        <el-table-column label="周期" width="210">
-          <template #default="{ row }">{{ row.start_date }} ~ {{ row.end_date }}</template>
+        <el-table-column prop="org_name" label="作用范围" min-width="110" show-overflow-tooltip />
+        <el-table-column label="周期" width="180">
+          <template #default="{ row }">
+            {{ row.start_date }} ~ {{ row.no_end ? "无期限" : row.end_date }}
+          </template>
         </el-table-column>
-        <el-table-column label="周期规则" width="150">
+        <el-table-column label="周期规则" width="118" show-overflow-tooltip>
           <template #default="{ row }">{{ ruleText(row) }}</template>
         </el-table-column>
-        <el-table-column label="模板 / 班次" width="160">
+        <el-table-column label="规则 / 班次" min-width="120" show-overflow-tooltip>
           <template #default="{ row }">
             <el-tag v-if="row.align_mode" size="small" type="warning">
-              {{ row.template_name || '模板规则' }}
+              {{ row.template_name || '涂刷规则' }}
             </el-tag>
             <span v-else>
               <span class="shift-dot" :style="{ background: row.color }" />{{ row.shift_name }}
             </span>
           </template>
         </el-table-column>
-        <el-table-column label="状态" width="90">
+        <el-table-column label="状态" width="74">
           <template #default="{ row }">
             <el-tag :type="row.publish_status === 1 ? 'success' : 'info'" size="small">
               {{ row.publish_status === 1 ? "已发布" : "未发布" }}
             </el-tag>
           </template>
         </el-table-column>
-        <el-table-column label="操作" width="210" fixed="right">
+        <el-table-column label="操作" width="150">
           <template #default="{ row }">
-            <el-button link type="primary" @click="publishPlan(row, false)">发布</el-button>
+            <el-button link type="primary" @click="publishPlan(row, false)">生成排班</el-button>
             <el-dropdown trigger="click" @command="(command) => handlePublishCommand(row, command)">
               <el-button link type="primary">更多<el-icon class="ml2"><ArrowDown /></el-icon></el-button>
               <template #dropdown>
@@ -88,235 +90,338 @@
       </div>
     </template>
 
-    <!-- 新建 / 编辑表单 -->
+    <!-- 新建 / 编辑表单：步骤 1 基础信息 → 步骤 2 排班策略 -->
     <template v-else>
       <div class="plan-form-head">
         <span class="form-title">{{ editingID ? "编辑排班方案" : "新建排班方案" }}</span>
         <el-button link @click="formVisible = false">返回方案列表</el-button>
       </div>
 
-      <el-form ref="formRef" :model="form" :rules="rules" label-width="92px">
-        <div class="form-grid">
-          <el-form-item label="方案名称" prop="plan_name">
-            <el-input v-model="form.plan_name" maxlength="100" placeholder="如：技术部 11 月早班" />
-          </el-form-item>
-          <el-form-item label="方案类型">
-            <el-radio-group v-model="form.plan_type">
-              <el-radio :value="1">常规排班</el-radio>
-              <el-radio :value="2">临时方案</el-radio>
-            </el-radio-group>
-          </el-form-item>
-          <el-form-item label="排班方式">
-            <el-radio-group v-model="form.rule_mode" @change="handleRuleModeChange">
-              <el-radio value="template">使用排班模板</el-radio>
-              <el-radio value="weekday">按星期排班</el-radio>
-            </el-radio-group>
-          </el-form-item>
-        </div>
+      <el-steps :active="step - 1" finish-status="success" simple class="plan-steps">
+        <el-step title="基础信息" @click="goStep(1)" />
+        <el-step title="排班策略" @click="goStep(2)" />
+      </el-steps>
 
-        <!-- 模板模式：套用平台模板的周期规则，规则会复制到本方案，可继续微调 -->
-        <template v-if="form.rule_mode === 'template'">
-          <div class="form-grid template-row">
-            <el-form-item label="排班模板" prop="template_id">
-              <el-select
-                v-model="form.template_id"
-                placeholder="选择模板"
-                style="width: 100%"
-                @change="handleTemplateChange"
-              >
-                <el-option
-                  v-for="tpl in templates"
-                  :key="tpl.id"
-                  :value="tpl.id"
-                  :label="`${tpl.name}（${tpl.template_type_text}）`"
-                />
-              </el-select>
+      <el-form ref="formRef" :model="form" :rules="rules" label-width="92px">
+        <!-- 步骤 1：基础信息 -->
+        <div v-show="step === 1">
+          <div class="form-grid">
+            <el-form-item label="方案名称" prop="plan_name">
+              <el-input v-model="form.plan_name" maxlength="100" placeholder="如：技术部 11 月早班" />
             </el-form-item>
-            <el-form-item label="模板规则">
-              <span class="template-summary">
-                {{ currentTemplate?.summary || '选择模板后自动带入规则' }}
-              </span>
+            <el-form-item label="方案类型">
+              <el-radio-group v-model="form.plan_type">
+                <el-radio :value="1">常规排班</el-radio>
+                <el-radio :value="2">临时方案</el-radio>
+              </el-radio-group>
+            </el-form-item>
+            <el-form-item label="排班方式">
+              <el-radio-group v-model="form.rule_mode">
+                <el-radio value="paint">按月涂排</el-radio>
+                <el-radio value="weekday">按星期排班</el-radio>
+              </el-radio-group>
+            </el-form-item>
+          </div>
+          <div class="form-grid">
+            <el-form-item label="排班模板">
+              <div class="shift-select-wrap">
+                <el-select
+                  v-model="form.tpl_id"
+                  placeholder="可选：调用模板快速填充涂刷节奏（标准工时 / 大小周等）"
+                  clearable
+                  filterable
+                  :loading="tplApplying"
+                  @change="onTemplateChange"
+                >
+                  <el-option
+                    v-for="tpl in templates"
+                    :key="tpl.id"
+                    :label="`${tpl.name}（${tpl.summary || `${tpl.cycle_days}天周期`}）`"
+                    :value="tpl.id"
+                  />
+                </el-select>
+                <span class="shift-meta">应用后自动匹配班次并把模板节奏平铺到涂刷画布，可继续调整</span>
+              </div>
             </el-form-item>
           </div>
 
-          <el-table
-            v-if="form.pattern.length"
-            :data="form.pattern"
-            size="small"
-            border
-            max-height="220"
-            class="pattern-table"
-          >
-            <el-table-column label="周期" width="110">
-              <template #default="{ $index }">{{ patternLabel($index) }}</template>
-            </el-table-column>
-            <el-table-column label="上班 / 休息" width="140">
-              <template #default="{ row }">
-                <el-radio-group v-model="row.day_type" size="small">
-                  <el-radio-button :value="1">上班</el-radio-button>
-                  <el-radio-button :value="2">休息</el-radio-button>
-                </el-radio-group>
-              </template>
-            </el-table-column>
-            <el-table-column label="班次" min-width="160">
-              <template #default="{ row }">
-                <el-select
-                  v-if="row.day_type === 1"
-                  v-model="row.shift_id"
-                  size="small"
-                  placeholder="选择班次"
-                  style="width: 100%"
-                  @change="applyShiftToPattern(row)"
-                >
+          <!-- 班次：唯一时间来源是班次管理 -->
+          <el-form-item label="班次" prop="shift_id">
+            <div class="shift-select-wrap">
+              <div class="shift-select-row">
+                <el-select v-model="form.shift_id" placeholder="选择班次（来自班次管理）" style="flex: 1">
                   <el-option
                     v-for="shift in shifts"
                     :key="shift.id"
+                    :label="shiftOptionLabel(shift)"
                     :value="shift.id"
-                    :label="`${shift.name}（${shift.work_start}-${shift.work_end}）`"
                   />
                 </el-select>
-                <span v-else class="rest-text">休息</span>
-              </template>
-            </el-table-column>
-            <el-table-column label="工作时间" width="180">
-              <template #default="{ row }">
-                <span v-if="row.day_type === 1">{{ row.work_start }} - {{ row.work_end }}</span>
-                <span v-else class="rest-text">-</span>
-              </template>
-            </el-table-column>
-          </el-table>
-          <div v-if="form.pattern.length" class="pattern-tip">
-            模板规则已复制到本方案，上面的调整只影响当前方案，不会修改平台模板
-          </div>
-        </template>
-
-        <!-- 按星期模式：一人一天一个固定班次 -->
-        <el-form-item v-else label="班次" prop="shift_id">
-          <el-select v-model="form.shift_id" placeholder="选择班次" style="width: 100%">
-            <el-option v-for="shift in shifts" :key="shift.id" :label="`${shift.name}（${shift.work_start}-${shift.work_end}）`" :value="shift.id" />
-          </el-select>
-        </el-form-item>
-
-        <el-form-item label="排班范围">
-          <el-radio-group v-model="form.scope_type">
-            <el-radio-button :value="1">整个公司</el-radio-button>
-            <el-radio-button :value="2">部门 / 小组</el-radio-button>
-            <el-radio-button :value="3">指定员工</el-radio-button>
-          </el-radio-group>
-        </el-form-item>
-
-        <div v-if="form.scope_type === 2" class="form-grid scope-row">
-          <el-form-item label="选择组织" prop="org_id">
-            <el-tree-select
-              v-model="form.org_id"
-              :data="orgTree"
-              :props="{ label: 'org_name', value: 'id', children: 'children' }"
-              node-key="id"
-              check-strictly
-              filterable
-              clearable
-              placeholder="选择公司、部门或小组"
-              style="width: 100%"
-            />
+                <el-button :icon="Plus" title="新增班次" @click="emit('open-shifts')" />
+              </div>
+              <span v-if="selectedShift" class="shift-meta">
+                {{ selectedShift.work_start }}-{{ selectedShift.work_end }}
+                <template v-if="selectedShift.rest_start">（休 {{ selectedShift.rest_start }}-{{ selectedShift.rest_end }}）</template>
+                · {{ selectedShift.work_hours || 0 }} 小时
+                <template v-if="selectedShift.remark"> · {{ selectedShift.remark }}</template>
+              </span>
+            </div>
           </el-form-item>
-          <el-form-item label="包含下级">
-            <el-switch v-model="form.include_child" active-text="含全部下级组织" />
-          </el-form-item>
-        </div>
-
-        <el-form-item v-if="form.scope_type === 3" label="选择员工" prop="employee_ids">
-          <el-select
-            v-model="form.employee_ids"
-            multiple
-            filterable
-            collapse-tags
-            collapse-tags-tooltip
-            placeholder="可选择一个或多个员工"
-            style="width: 100%"
+          <el-alert
+            v-if="!shifts.length"
+            class="shift-empty-alert"
+            type="warning"
+            show-icon
+            :closable="false"
           >
-            <el-option
-              v-for="employee in employees"
-              :key="employee.id"
-              :label="employee.label"
-              :value="employee.id"
-            />
-          </el-select>
-        </el-form-item>
+            <template #title>当前还没有可用班次，无法配置排班规则</template>
+            <div class="shift-empty-body">
+              <span>班次的上班时间统一取自【班次管理】，请先创建班次后再回来配置排班。</span>
+              <el-button type="warning" size="small" plain @click="emit('open-shifts')">
+                去创建班次
+              </el-button>
+            </div>
+          </el-alert>
 
-        <div class="form-grid">
-          <el-form-item label="日期范围" prop="date_range">
-            <el-date-picker
-              v-model="form.date_range"
-              type="daterange"
-              value-format="YYYY-MM-DD"
-              start-placeholder="开始日期"
-              end-placeholder="结束日期"
-              :clearable="false"
-              style="width: 100%"
-            />
+          <el-form-item label="排班范围">
+            <el-radio-group v-model="form.scope_type">
+              <el-radio-button :value="1">整个公司</el-radio-button>
+              <el-radio-button :value="2">部门 / 小组</el-radio-button>
+              <el-radio-button :value="3">指定员工</el-radio-button>
+            </el-radio-group>
           </el-form-item>
-          <el-form-item v-if="form.rule_mode === 'weekday'" label="生效星期">
-            <el-checkbox-group v-model="form.weekdays">
-              <el-checkbox v-for="day in WEEKDAYS" :key="day.value" :value="day.value">{{ day.label }}</el-checkbox>
-            </el-checkbox-group>
+
+          <div v-if="form.scope_type === 2" class="form-grid scope-row">
+            <el-form-item label="选择组织" prop="org_id">
+              <el-tree-select
+                v-model="form.org_id"
+                :data="orgTree"
+                :props="{ label: 'org_name', value: 'id', children: 'children' }"
+                node-key="id"
+                check-strictly
+                filterable
+                clearable
+                placeholder="选择公司、部门或小组"
+                style="width: 100%"
+              />
+            </el-form-item>
+            <el-form-item label="包含下级">
+              <el-switch v-model="form.include_child" active-text="含全部下级组织" />
+            </el-form-item>
+          </div>
+
+          <el-form-item v-if="form.scope_type === 3" label="选择员工" prop="employee_ids">
+            <el-select
+              v-model="form.employee_ids"
+              multiple
+              filterable
+              collapse-tags
+              collapse-tags-tooltip
+              placeholder="可选择一个或多个员工"
+              style="width: 100%"
+            >
+              <el-option
+                v-for="employee in employees"
+                :key="employee.id"
+                :label="employee.label"
+                :value="employee.id"
+              />
+            </el-select>
+          </el-form-item>
+
+          <el-form-item label="备注">
+            <el-input v-model="form.note" maxlength="500" placeholder="选填，会带到生成的排班备注里" />
           </el-form-item>
         </div>
 
-        <el-form-item label="备注">
-          <el-input v-model="form.note" maxlength="500" placeholder="选填，会带到生成的排班备注里" />
-        </el-form-item>
+        <!-- 步骤 2：排班策略 -->
+        <div v-show="step === 2">
+          <!-- 按月涂排：直接在月历上涂刷（单击切换 上班/休息，拖拽批量涂） -->
+          <template v-if="form.rule_mode === 'paint'">
+            <div class="paint-canvas">
+              <div class="paint-month-bar">
+                <el-button-group>
+                  <el-button size="small" :icon="ArrowLeft" @click="shiftPaintMonth(-1)" />
+                  <el-button size="small" @click="goPaintToday">本月</el-button>
+                  <el-button size="small" :icon="ArrowRight" @click="shiftPaintMonth(1)" />
+                </el-button-group>
+                <span class="paint-month">{{ paintMonthText }}</span>
+                <span class="paint-stats">
+                  上班 <strong>{{ paintStats.work }}</strong> 天 ·
+                  休息 <strong>{{ paintStats.rest }}</strong> 天 ·
+                  未涂 <strong>{{ paintStats.unset }}</strong> 天
+                </span>
+                <el-button link type="danger" size="small" @click="clearPaintMonth">清空本月涂刷</el-button>
+              </div>
+              <div class="paint-tip">
+                点击日期在 上班 / 休息 之间切换；按住拖拽可批量涂刷。
+                法定调休上班日即使是周末也按上班；翻到涂刷月之后的月份可预览顺延结果（周一~周五按涂刷节奏上班，节假日、周末休息，调休上班日除外；隔周交替的星期如大小周的周六会按周序继续交替）；点击预览月可改为从该月起重新涂刷。
+              </div>
+              <div class="paint-row">
+                  <span class="paint-extend-label">顺延至</span>
+                  <el-date-picker
+                    v-model="form.extend_month"
+                    type="month"
+                    value-format="YYYY-MM"
+                    :clearable="false"
+                    :disabled="form.no_end"
+                    size="small"
+                    style="width: 130px"
+                    @change="handleExtendChange"
+                  />
+                  <el-checkbox v-model="form.no_end" size="small" @change="handleNoEndChange">无期限</el-checkbox>
+                  <el-button
+                    type="primary"
+                    size="small"
+                    :loading="generating"
+                    @click="generateFromPaint"
+                  >延续涂装</el-button>
+                  <span class="paint-extend-hint">
+                    {{
+                      form.no_end
+                        ? '无期限方案生成到当年 12 月 31 日'
+                        : '涂刷月规则按周期滚动顺延到所选月份（选涂刷月即只排当月）'
+                    }}
+                  </span>
+                </div>
+                <div class="timeline-week">
+                  <span v-for="name in TIMELINE_WEEKDAYS" :key="name">{{ name }}</span>
+                </div>
+                <div
+                  class="timeline-grid paint-grid"
+                  @mouseup="stopPaint"
+                  @mouseleave="stopPaint"
+                >
+                  <div
+                    v-for="cell in paintCells"
+                    :key="cell.key"
+                    class="timeline-cell"
+                    :class="[
+                      cell.blank ? 'is-blank' : '',
+                      cell.state === 'work' ? 'is-work' : '',
+                      cell.state === 'rest' ? 'is-rest-painted' : '',
+                      cell.state === 'unset' ? 'is-unset' : '',
+                      cell.inherited ? 'is-inherited' : '',
+                      cell.holidayType === 1 && cell.state === 'unset' ? 'is-holiday-off' : '',
+                      cell.holidayType === 0 && cell.state === 'unset' ? 'is-holiday-work' : '',
+                      !cell.holidayType && cell.weekend && cell.state === 'unset' ? 'is-weekend' : ''
+                    ]"
+                    @mousedown="startPaint(cell)"
+                    @mouseenter="movePaint(cell)"
+                  >
+                    <template v-if="!cell.blank">
+                      <div class="cell-date">
+                        <span>{{ cell.day }}</span>
+                        <div class="cell-tags">
+                          <span v-if="cell.holidayType === 1" class="cell-tag is-off">休</span>
+                          <span v-else-if="cell.holidayType === 0" class="cell-tag is-workday">班</span>
+                          <span v-else-if="cell.weekend" class="cell-tag is-weekend">周末</span>
+                          <span v-if="cell.today" class="cell-tag is-today">今</span>
+                        </div>
+                      </div>
+                      <div v-if="cell.state === 'work'" class="cell-shift">
+                        <span class="cell-shift-name">
+                          {{ cell.shortName || cell.shiftName || '上班' }}<i v-if="cell.inherited" class="inh-tag">延续</i>
+                        </span>
+                        <span class="cell-shift-time">{{ cell.workStart }}-{{ cell.workEnd }}</span>
+                      </div>
+                      <div v-else-if="cell.state === 'rest'" class="cell-shift is-rest-text">
+                        休息<i v-if="cell.inherited" class="inh-tag">延续</i>
+                      </div>
+                      <div v-else class="cell-shift muted">未涂</div>
+                      <div v-if="cell.holidayName" class="cell-holiday-name">
+                        {{ cell.holidayName }}
+                      </div>
+                    </template>
+                  </div>
+                </div>
+                <div class="timeline-legend">
+                  <span><i class="dot is-work-dot" />上班</span>
+                  <span><i class="dot is-rest-dot" />休息</span>
+                  <span><i class="dot is-unset-dot" />未涂（保存时按休息处理；周末默认休息；调休上班日按上班）</span>
+                  <span><i class="dot is-weekend-dot" />周末</span>
+                  <span><i class="dot is-holiday-dot" />法定节假日</span>
+                </div>
+            </div>
+          </template>
+
+          <!-- 按星期排班：开始 / 结束日期（可无期限）+ 生效星期 -->
+          <template v-else>
+            <div class="form-grid scope-row">
+              <el-form-item label="开始日期" prop="date_range">
+                <div class="date-noend-row">
+                  <el-date-picker
+                    v-model="startDateOnly"
+                    type="date"
+                    value-format="YYYY-MM-DD"
+                    placeholder="开始日期"
+                    :clearable="false"
+                    style="width: 140px"
+                  />
+                  <template v-if="!form.no_end">
+                    <span class="date-sep">~</span>
+                    <el-date-picker
+                      v-model="endDateOnly"
+                      type="date"
+                      value-format="YYYY-MM-DD"
+                      placeholder="结束日期"
+                      :clearable="false"
+                      style="width: 140px"
+                    />
+                  </template>
+                  <el-checkbox v-model="form.no_end" @change="handleNoEndChange">无期限</el-checkbox>
+                </div>
+              </el-form-item>
+              <el-form-item label="生效星期">
+                <el-checkbox-group v-model="form.weekdays">
+                  <el-checkbox v-for="day in WEEKDAYS" :key="day.value" :value="day.value">{{ day.label }}</el-checkbox>
+                </el-checkbox-group>
+              </el-form-item>
+            </div>
+            <div class="weekday-tip">
+              范围内的「生效星期」按所选班次生成排班，其余日期不排。勾选「无期限」后生成到当年 12 月 31 日，新的一年重新排即可。
+            </div>
+          </template>
+        </div>
       </el-form>
 
-      <div v-if="preview" class="preview-box">
-        <el-alert v-if="!preview.employee_count" type="warning" :closable="false" show-icon
-          title="该范围内没有可排班的员工，请检查所选组织或员工状态" />
-        <el-alert v-else type="success" :closable="false" show-icon>
-          <template #title>
-            将覆盖 <strong>{{ preview.employee_count }}</strong> 名员工 ×
-            <strong>{{ preview.workday_count }}</strong> 个工作日，共
-            <strong>{{ preview.entry_count }}</strong> 条排班
-          </template>
-        </el-alert>
-        <div v-if="preview.employee_list?.length" class="preview-employees">
-          <el-tag v-for="item in preview.employee_list.slice(0, 30)" :key="item.id" size="small" type="info">
-            {{ item.name }}<span v-if="item.department_name"> · {{ item.department_name }}</span>
-          </el-tag>
-          <span v-if="preview.employee_list.length > 30" class="more-tip">
-            等 {{ preview.employee_list.length }} 人
-          </span>
-        </div>
-      </div>
-
       <div class="form-actions">
-        <el-button :loading="previewing" @click="runPreview">预览覆盖范围</el-button>
-        <el-button @click="formVisible = false">取消</el-button>
-        <el-button type="primary" :loading="saving" @click="savePlan">保存方案</el-button>
+        <template v-if="step === 1">
+          <el-button @click="formVisible = false">取消</el-button>
+          <el-button type="primary" @click="nextStep">下一步：排班策略</el-button>
+        </template>
+        <template v-else>
+          <el-button @click="step = 1">上一步</el-button>
+          <el-button @click="formVisible = false">取消</el-button>
+          <el-button type="primary" :loading="saving" @click="savePlan">保存方案</el-button>
+        </template>
       </div>
     </template>
   </el-dialog>
 </template>
 
 <script setup>
-import { reactive, ref } from 'vue'
-import { ArrowDown, Plus } from '@element-plus/icons-vue'
+import { computed, onBeforeUnmount, onMounted, reactive, ref, watch } from 'vue'
+import { ArrowDown, ArrowLeft, ArrowRight, Plus } from '@element-plus/icons-vue'
 import { ElMessage, ElMessageBox } from 'element-plus'
 import { oaOrganizationApi } from '@/api/organization'
 import { buildOrgTree } from '@/views/apps/organization/composables'
-import { getSchedulingEmployees, getShiftList } from '@/api/oaScheduling'
+import { getScheduleHolidays } from '@/api/oaSchedule'
 import {
   applySchedTemplate,
   createSchedulePlan,
   deleteSchedulePlan,
   getSchedulePlanDetail,
-  getSchedTemplates,
   getSchedulePlans,
-  previewSchedulePlan,
+  getSchedTemplates,
+  getSchedulingEmployees,
+  getShiftList,
   publishSchedulePlan,
   updateSchedulePlan
 } from '@/api/oaScheduling'
 
 defineProps({ modelValue: Boolean })
-const emit = defineEmits(['update:modelValue', 'changed'])
+const emit = defineEmits(['update:modelValue', 'changed', 'open-shifts'])
 
 const WEEKDAYS = [
   { value: 1, label: '周一' },
@@ -327,6 +432,7 @@ const WEEKDAYS = [
   { value: 6, label: '周六' },
   { value: 7, label: '周日' }
 ]
+const TIMELINE_WEEKDAYS = ['一', '二', '三', '四', '五', '六', '日']
 
 function unwrap(res) {
   if (res && typeof res === 'object' && 'code' in res) {
@@ -338,55 +444,98 @@ function unwrap(res) {
 
 const loading = ref(false)
 const saving = ref(false)
-const previewing = ref(false)
 const plans = ref([])
 const shifts = ref([])
-const templates = ref([])
-const currentTemplate = ref(null)
 const employees = ref([])
 const orgTree = ref([])
 const keyword = ref('')
 const pagination = reactive({ page: 1, pageSize: 20, total: 0 })
 
+// 排班模板（平台预置 + 自定义，只读），用于快速填充策略
+// 应用模板 = 一次性把规则预填到画布，之后完全自由涂刷
+const templates = ref([])
+const tplApplying = ref(false)
+
 const formVisible = ref(false)
 const editingID = ref(0)
-const preview = ref(null)
 const formRef = ref(null)
+// 步骤：1 基础信息 → 2 排班策略
+const step = ref(1)
+// 涂刷画布状态
+const paintMonth = ref('')
+const isPainting = ref(false)
+const paintMap = ref({}) // 日期 YYYY-MM-DD -> 'work' | 'rest'（仅存显式标记）
+// 拖拽期间要涂的目标状态：'work' | 'rest' | null（null 表示拖拽清除显式标记）
+const paintDragValue = ref(null)
+
+// 法定节假日 / 调休映射，键为 YYYY-MM-DD
+const holidayMap = ref({})
+const loadedHolidayYears = new Set()
 
 const form = reactive({
   plan_name: '',
   plan_type: 1,
-  rule_mode: 'weekday',
+  rule_mode: 'paint',
+  tpl_id: null,
   shift_id: null,
-  template_id: null,
-  template_code: '',
-  template_name: '',
-  align_mode: 0,
-  cycle_days: 0,
-  week_offset: 0,
-  month_rest_days: 0,
-  month_rest_weekday: 0,
-  pattern: [],
   scope_type: 2,
   org_id: null,
   include_child: true,
   employee_ids: [],
   date_range: [],
+  no_end: false,
   weekdays: [1, 2, 3, 4, 5],
+  extend_month: '',
   note: ''
 })
 
 const rules = {
   plan_name: [{ required: true, message: '请输入方案名称', trigger: 'blur' }],
+  shift_id: [{ required: true, message: '请选择班次', trigger: 'change' }],
   org_id: [{ required: true, message: '请选择组织', trigger: 'change' }],
-  employee_ids: [{ required: true, message: '请选择员工', trigger: 'change' }],
-  date_range: [{ required: true, message: '请选择日期范围', trigger: 'change' }]
+  employee_ids: [{ required: true, message: '请选择员工', trigger: 'change' }]
+}
+
+const selectedShift = computed(() => shifts.value.find((item) => item.id === form.shift_id) || null)
+
+// 按星期模式：开始 / 结束日期单独读写（无期限时只保留开始日期）
+const startDateOnly = computed({
+  get: () => form.date_range?.[0] || '',
+  set: (value) => {
+    const end = form.no_end ? '' : form.date_range?.[1] || ''
+    form.date_range = [value, end].filter(Boolean)
+  }
+})
+const endDateOnly = computed({
+  get: () => (!form.no_end && form.date_range?.[1]) || '',
+  set: (value) => {
+    const start = form.date_range?.[0] || value
+    form.date_range = [start, value]
+  }
+})
+
+// 勾选 / 取消无期限时整理日期区间
+function handleNoEndChange(checked) {
+  if (checked) {
+    form.date_range = form.date_range?.[0] ? [form.date_range[0]] : []
+  } else if (form.date_range?.[0]) {
+    form.date_range = [form.date_range[0], form.date_range[0]]
+  }
 }
 
 async function handleOpen() {
   formVisible.value = false
-  preview.value = null
-  await Promise.all([loadPlans(), loadShifts(), loadTemplates(), loadEmployees(), loadOrgs()])
+  step.value = 1
+  await Promise.all([loadPlans(), loadShifts(), loadEmployees(), loadOrgs(), loadTemplates()])
+}
+
+async function loadTemplates() {
+  try {
+    const data = unwrap(await getSchedTemplates()) || {}
+    templates.value = data.list || []
+  } catch {
+    templates.value = []
+  }
 }
 
 async function loadPlans() {
@@ -415,15 +564,6 @@ async function loadShifts() {
   }
 }
 
-async function loadTemplates() {
-  try {
-    const data = unwrap(await getSchedTemplates({})) || {}
-    templates.value = data.list || []
-  } catch {
-    templates.value = []
-  }
-}
-
 async function loadEmployees() {
   try {
     const data = unwrap(await getSchedulingEmployees({})) || {}
@@ -445,16 +585,500 @@ async function loadOrgs() {
   }
 }
 
-function openCreate() {
-  editingID.value = 0
-  preview.value = null
-  currentTemplate.value = null
-  Object.assign(form, {
-    plan_name: '',
-    plan_type: 1,
-    rule_mode: 'weekday',
-    shift_id: shifts.value.find((item) => item.is_default === 1)?.id || shifts.value[0]?.id || null,
-    template_id: null,
+function pad2(value) {
+  return String(value).padStart(2, '0')
+}
+
+function formatDate(date) {
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`
+}
+
+function todayText() {
+  return formatDate(new Date())
+}
+
+// 自然月的首末日
+function monthBounds(ym) {
+  const [year, month] = ym.split('-').map(Number)
+  const lastDay = new Date(year, month, 0).getDate()
+  return [`${year}-${pad2(month)}-01`, `${year}-${pad2(month)}-${pad2(lastDay)}`]
+}
+
+// 某天是周几（返回 1-7，周一=1）
+function weekdayOfDay(dateText) {
+  const [y, m, d] = dateText.split('-').map(Number)
+  const week = new Date(y, m - 1, d).getDay()
+  return week === 0 ? 7 : week
+}
+
+function currentMonthText() {
+  const now = new Date()
+  return `${now.getFullYear()}-${pad2(now.getMonth() + 1)}`
+}
+
+function shiftPaintMonthText(ym) {
+  const [year, month] = ym.split('-')
+  return `${year} 年 ${Number(month)} 月`
+}
+
+// 节假日数据按年加载，加载失败不影响主流程（只少了节假日标记）
+async function loadHolidays(year) {
+  if (!year || loadedHolidayYears.has(year)) return
+  try {
+    const data = unwrap(await getScheduleHolidays({ year })) || {}
+    const map = { ...holidayMap.value }
+    ;(data.list || data || []).forEach((item) => {
+      if (item && item.date) map[item.date] = item
+    })
+    holidayMap.value = map
+    loadedHolidayYears.add(year)
+  } catch {
+    loadedHolidayYears.add(year)
+  }
+}
+
+/* ---------------- 涂刷画布 ---------------- */
+
+const paintMonthText = computed(() => (paintMonth.value ? shiftPaintMonthText(paintMonth.value) : ''))
+
+// 单日生效状态：显式标记 > 法定调休上班日（含周末）默认上班 > 周末未标记默认休息
+// > 工作日未标记（保存时按休息处理）。
+// 不再做周末「延续」继承：未标记的周末一律按休息，需要上班请显式点击标记。
+function resolveCellState(mark, holidayType, weekday) {
+  if (mark === 'work' || mark === 'rest') {
+    return { state: mark, inherited: false }
+  }
+  // 法定调休上班日：即使是周末也按上班
+  if (holidayType === 0) return { state: 'work', inherited: false }
+  if (weekday === 6 || weekday === 7) {
+    // 周末未标记：默认休息
+    return { state: 'rest', inherited: false }
+  }
+  return { state: 'unset', inherited: false }
+}
+
+// 涂刷基准月：paintMap 里最早的月份（保存与顺延预览共用同一锚点）
+const paintBaseYm = computed(() => {
+  const months = Object.keys(paintMap.value).map((date) => date.slice(0, 7)).sort()
+  return months[0] || ''
+})
+
+// 方案是否向涂刷月之后顺延（无期限，或顺延月晚于涂刷月）
+const paintExtends = computed(() => {
+  if (!paintBaseYm.value) return false
+  return form.no_end || Boolean(form.extend_month && form.extend_month > paintBaseYm.value)
+})
+
+// 涂刷月按保存规则解析后的逐日状态（与 buildPaintPayload 同一套生效规则）。
+// 未标记的工作日保存时按休息处理，所以这里把 unset 归并为 rest，
+// 保证顺延预览和实际生成结果一致。
+const basePatternStates = computed(() => {
+  const ym = paintBaseYm.value
+  if (!ym) return []
+  const [, last] = monthBounds(ym)
+  const lastDay = Number(last.slice(8, 10))
+  const states = []
+  for (let day = 1; day <= lastDay; day += 1) {
+    const dateText = `${ym}-${pad2(day)}`
+    const holiday = holidayMap.value[dateText] || null
+    const eff = resolveCellState(
+      paintMap.value[dateText],
+      holiday ? Number(holiday.type) : null,
+      weekdayOfDay(dateText)
+    ).state
+    states.push(eff === 'work' ? 'work' : 'rest')
+  }
+  return states
+})
+
+// 涂刷月的星期节奏：同星期几取周期内多数状态（与后端 scBuildRollExt 同规则），
+// 下标 1-7 对应周一~周日，true 表示该星期顺延时上班
+const baseWeekdayStates = computed(() => {
+  const states = basePatternStates.value
+  const baseYm = paintBaseYm.value
+  const result = [null, false, false, false, false, false, false, false]
+  if (!states.length || !baseYm) return result
+  const score = [0, 0, 0, 0, 0, 0, 0, 0]
+  states.forEach((state, i) => {
+    const w = weekdayOfDay(`${baseYm}-${pad2(i + 1)}`)
+    score[w] += state === 'work' ? 1 : -1
+  })
+  for (let w = 1; w <= 7; w += 1) {
+    result[w] = score[w] >= 0
+  }
+  return result
+})
+
+// 涂刷月 1 号所在周的周一（与后端 start 周序锚点对齐，用于隔周交替推算）
+function baseAnchorMonday(baseYm) {
+  const first = `${baseYm}-01`
+  const [y, m, d] = first.split('-').map(Number)
+  return new Date(y, m - 1, d - (weekdayOfDay(first) - 1))
+}
+
+// 涂刷月的隔周交替节奏：某星期在涂刷月内严格 休/班 交替（如大小周的周六，
+// 一周上班一周休息）时，顺延按周序奇偶保持交替（与后端 scBuildRollExt 同规则）
+const baseAltStates = computed(() => {
+  const result = []
+  for (let i = 0; i <= 7; i += 1) result.push({ alt: false, even: false, odd: false })
+  const states = basePatternStates.value
+  const baseYm = paintBaseYm.value
+  if (!states.length || !baseYm) return result
+  const anchorMonday = baseAnchorMonday(baseYm)
+  const seqs = [[], [], [], [], [], [], [], []]
+  states.forEach((state, i) => {
+    const dateText = `${baseYm}-${pad2(i + 1)}`
+    const w = weekdayOfDay(dateText)
+    const [y, m, d] = dateText.split('-').map(Number)
+    const monday = new Date(y, m - 1, d - (w - 1))
+    const week = Math.round((monday - anchorMonday) / (7 * 86400000))
+    seqs[w].push({ week, work: state === 'work' })
+  })
+  for (let w = 1; w <= 7; w += 1) {
+    const list = seqs[w]
+    if (list.length < 2) continue
+    let alt = true
+    for (let i = 1; i < list.length; i += 1) {
+      if (list[i].work === list[i - 1].work) {
+        alt = false
+        break
+      }
+    }
+    if (!alt) continue
+    if (list[0].week % 2 === 0) {
+      result[w] = { alt: true, even: list[0].work, odd: list[1].work }
+    } else {
+      result[w] = { alt: true, even: list[1].work, odd: list[0].work }
+    }
+  }
+  return result
+})
+
+// 顺延预览：涂刷月之后的日期按「星期节奏 + 目标月节假日/周末特殊规则」推算，
+// 与后端 scRuleForDate 的周期外顺延保持一致——
+// 法定节假日休息、调休上班日上班；隔周交替的星期（如大小周的周六）按周序奇偶
+// 继续交替；其余按涂刷月的星期节奏（周一~周五正常上班）
+function rolledStateFor(dateText) {
+  if (!paintExtends.value) return null
+  const baseYm = paintBaseYm.value
+  if (!baseYm || dateText.slice(0, 7) <= baseYm) return null
+  const holiday = holidayMap.value[dateText] || null
+  if (holiday) {
+    const type = Number(holiday.type)
+    if (type === 1) return { state: 'rest', inherited: true }
+    if (type === 0) return { state: 'work', inherited: true }
+  }
+  if (!basePatternStates.value.length) return null
+  const weekday = weekdayOfDay(dateText)
+  // 隔周交替的星期（如大小周的周六）：按周序奇偶保持交替
+  const alt = baseAltStates.value[weekday]
+  if (alt && alt.alt) {
+    const anchorMonday = baseAnchorMonday(baseYm)
+    const [y, m, d] = dateText.split('-').map(Number)
+    const monday = new Date(y, m - 1, d - (weekday - 1))
+    const week = Math.round((monday - anchorMonday) / (7 * 86400000))
+    return { state: (week % 2 === 0 ? alt.even : alt.odd) ? 'work' : 'rest', inherited: true }
+  }
+  return { state: baseWeekdayStates.value[weekday] ? 'work' : 'rest', inherited: true }
+}
+
+const paintCells = computed(() => {
+  if (!paintMonth.value) return []
+  const ym = paintMonth.value
+  const [first, last] = monthBounds(ym)
+  const daysInMonth = Number(last.slice(8, 10))
+  const today = todayText()
+  const shift = selectedShift.value
+  const cells = []
+  // 首日前的空白占位，让日期对齐星期
+  const offset = weekdayOfDay(first) - 1
+  for (let i = 0; i < offset; i += 1) {
+    cells.push({ key: `blank-${i}`, blank: true })
+  }
+  for (let day = 1; day <= daysInMonth; day += 1) {
+    const dateText = `${ym}-${pad2(day)}`
+    const holiday = holidayMap.value[dateText] || null
+    const holidayType = holiday ? Number(holiday.type) : null
+    const weekday = weekdayOfDay(dateText)
+    // 顺延月直接展示滚动结果（只读）；涂刷月内仍按显式标记 + 默认规则解析
+    const rolled = rolledStateFor(dateText)
+    const resolved = rolled || resolveCellState(paintMap.value[dateText], holidayType, weekday)
+    cells.push({
+      key: dateText,
+      date: dateText,
+      day,
+      state: resolved.state,
+      inherited: resolved.inherited,
+      preview: Boolean(rolled),
+      today: dateText === today,
+      weekend: weekday === 6 || weekday === 7,
+      holidayType,
+      holidayName: holiday?.name || '',
+      shiftName: shift?.name || '',
+      shortName: shift?.short_name || '',
+      workStart: shift?.work_start || '',
+      workEnd: shift?.work_end || ''
+    })
+  }
+  return cells
+})
+
+// 本月涂刷统计
+const paintStats = computed(() => {
+  const stats = { work: 0, rest: 0, unset: 0 }
+  paintCells.value.forEach((cell) => {
+    if (cell.blank) return
+    if (cell.state === 'work') stats.work += 1
+    else if (cell.state === 'rest') stats.rest += 1
+    else stats.unset += 1
+  })
+  return stats
+})
+
+// 直接涂刷：单击在 上班 / 休息 之间切换，拖拽批量涂
+function startPaint(cell) {
+  if (cell.blank) return
+  // 顺延预览月只读；点击可确认改为从该月起重新涂刷
+  if (cell.preview) {
+    switchPaintBase(cell.date.slice(0, 7))
+    return
+  }
+  // 只在 上班 / 休息 之间切换
+  const next = paintMap.value[cell.date] === 'work' ? 'rest' : 'work'
+  paintMap.value[cell.date] = next
+  paintDragValue.value = next
+  isPainting.value = true
+}
+
+function movePaint(cell) {
+  if (!isPainting.value || cell.blank || cell.preview) return
+  const value = paintDragValue.value
+  if (value) paintMap.value[cell.date] = value
+  else delete paintMap.value[cell.date]
+}
+
+function stopPaint() {
+  isPainting.value = false
+}
+
+// 兜底：鼠标在日历外（甚至弹窗外）松开也要结束拖拽，避免之后滑动误涂
+onMounted(() => window.addEventListener('mouseup', stopPaint))
+onBeforeUnmount(() => window.removeEventListener('mouseup', stopPaint))
+
+// 把周期 pattern 平铺到涂刷月画布：第 d 天取 pattern[(d-1) % cycle] 的状态。
+// 用于模板应用 / 编辑非整月周期方案（如大小周）时预填当前节奏，可继续自由调整
+function fillPaintFromPattern(pattern, cycle) {
+  const ym = paintMonth.value
+  if (!ym || !pattern?.length) return
+  paintMap.value = {}
+  if (!cycle || cycle < 1) cycle = pattern.length
+  const byIndex = new Map(pattern.map((item) => [Number(item.day_index), item]))
+  const [, last] = monthBounds(ym)
+  const lastDay = Number(last.slice(8, 10))
+  for (let day = 1; day <= lastDay; day += 1) {
+    const item = byIndex.get((day - 1) % cycle)
+    if (!item) continue
+    paintMap.value[`${ym}-${pad2(day)}`] = Number(item.day_type) === 1 ? 'work' : 'rest'
+  }
+}
+
+// 班次下拉选项文案：名称 + 时间段 + 备注，方便分辨相近的班次
+function shiftOptionLabel(shift) {
+  let label = `${shift.name}（${shift.work_start || '?'}-${shift.work_end || '?'}`
+  if (shift.remark) label += ` · ${shift.remark}`
+  return `${label}）`
+}
+
+// 应用排班模板：匹配班次（不自动创建），把模板规则一次性预填到画布，之后自由涂刷
+async function onTemplateChange(tplId) {
+  if (!tplId) return
+  tplApplying.value = true
+  try {
+    const data = unwrap(await applySchedTemplate(tplId)) || {}
+    const pattern = Array.isArray(data.pattern) ? data.pattern : []
+    if (!pattern.length) {
+      ElMessage.warning('该模板没有排班规则，未做填充')
+      return
+    }
+    const shiftIds = [...new Set(pattern.filter((item) => Number(item.day_type) === 1 && item.shift_id).map((item) => item.shift_id))]
+    if (shiftIds.length) {
+      if (shiftIds.length > 1) ElMessage.info('模板包含多个班次，已使用第一个班次填充')
+      form.shift_id = shiftIds[0]
+    }
+    const tpl = data.template || {}
+    form.rule_mode = 'paint'
+    paintMonth.value = paintMonth.value || currentMonthText()
+    fillPaintFromPattern(pattern, Number(tpl.cycle_days) || pattern.length)
+    loadHolidays(Number(paintMonth.value.slice(0, 4)))
+    ElMessage.success(`已应用模板「${tpl.name || ''}」：规则已预填到 ${paintMonth.value} 画布，可自由调整后保存`)
+  } catch (error) {
+    ElMessage.error(error.message || '应用模板失败')
+  } finally {
+    tplApplying.value = false
+  }
+}
+
+// 切到涂排模式时画布若为空，按当前星期配置预填节奏（如周一~周五上班），
+// 避免编辑已有方案时从零开始涂
+watch(
+  () => form.rule_mode,
+  (mode) => {
+    if (mode !== 'paint') return
+    if (Object.keys(paintMap.value).length) return
+    const ym = paintMonth.value
+    if (!ym) return
+    const [, last] = monthBounds(ym)
+    const lastDay = Number(last.slice(8, 10))
+    for (let day = 1; day <= lastDay; day += 1) {
+      const dateText = `${ym}-${pad2(day)}`
+      paintMap.value[dateText] = form.weekdays.includes(weekdayOfDay(dateText)) ? 'work' : 'rest'
+    }
+  }
+)
+
+function clearPaintMonth() {
+  if (!paintMonth.value) return
+  const ym = paintMonth.value
+  Object.keys(paintMap.value).forEach((date) => {
+    if (date.startsWith(ym)) delete paintMap.value[date]
+  })
+}
+
+// 改为从某个月起重新涂刷：清空现有标记，该月成为新的涂刷基准月
+// （方案开始日期随之变为该月 1 号；已生成的历史排班不受影响）
+function switchPaintBase(ym) {
+  const baseYm = paintBaseYm.value
+  ElMessageBox.confirm(
+    `<div class="gen-confirm">
+      <p>当前涂刷月：<b>${baseYm}</b></p>
+      <p>改为从 <b>${ym}</b> 起重新涂刷：将清空现有涂刷标记，方案开始日期变为 <b>${ym}-01</b>；已生成的历史排班不受影响。</p>
+    </div>`,
+    '修改涂刷月',
+    { dangerouslyUseHTMLString: true, type: 'warning', confirmButtonText: `从 ${ym} 重新涂刷`, cancelButtonText: '取消' }
+  )
+    .then(() => {
+      paintMap.value = {}
+      isPainting.value = false
+      paintMonth.value = ym
+      loadHolidays(Number(ym.slice(0, 4)))
+      // 顺延月不早于新的涂刷月
+      if (!form.no_end && form.extend_month && form.extend_month < ym) {
+        form.extend_month = ym
+      }
+      ElMessage.success(`涂刷月已切换到 ${ym}，请重新涂刷后点「延续涂装」保存`)
+    })
+    .catch(() => {})
+}
+
+function shiftPaintMonth(delta) {
+  if (!paintMonth.value) paintMonth.value = currentMonthText()
+  const [year, month] = paintMonth.value.split('-').map(Number)
+  const next = new Date(year, month - 1 + delta, 1)
+  paintMonth.value = `${next.getFullYear()}-${pad2(next.getMonth() + 1)}`
+  // 顺延月不早于涂刷月
+  if (form.extend_month && form.extend_month < paintMonth.value) {
+    form.extend_month = paintMonth.value
+  }
+  loadHolidays(next.getFullYear())
+}
+
+function goPaintToday() {
+  paintMonth.value = currentMonthText()
+  if (form.extend_month && form.extend_month < paintMonth.value) {
+    form.extend_month = paintMonth.value
+  }
+  loadHolidays(Number(paintMonth.value.slice(0, 4)))
+}
+
+function handleExtendChange(value) {
+  if (value && paintMonth.value && value < paintMonth.value) {
+    form.extend_month = paintMonth.value
+    ElMessage.info('顺延月份不能早于涂刷月份，已自动调整')
+  }
+  if (value) loadHolidays(Number(value.slice(0, 4)))
+}
+
+/* ---------------- 步骤流转与校验 ---------------- */
+
+// 步骤条点击切换：回第 1 步直接切，进第 2 步先校验基础信息
+function goStep(target) {
+  if (target === step.value) return
+  if (target === 2 && !validateBasic()) return
+  step.value = target
+}
+
+function validateBasic() {
+  if (!String(form.plan_name || '').trim()) {
+    ElMessage.warning('请输入方案名称')
+    return false
+  }
+  if (!shifts.value.length) {
+    ElMessage.warning('当前还没有班次，请先到【班次管理】创建班次')
+    return false
+  }
+  if (!form.shift_id) {
+    ElMessage.warning('请选择班次（班次的上班时间取自班次管理）')
+    return false
+  }
+  if (form.scope_type === 2 && !form.org_id) {
+    ElMessage.warning('请选择要排班的部门或小组')
+    return false
+  }
+  if (form.scope_type === 3 && !form.employee_ids.length) {
+    ElMessage.warning('请选择需要排班的员工')
+    return false
+  }
+  return true
+}
+
+function nextStep() {
+  if (!validateBasic()) return
+  step.value = 2
+}
+
+// 步骤 2 校验：按月涂排要求有涂刷结果；按星期要求日期与星期
+function validateStrategy() {
+  if (form.rule_mode === 'paint') {
+    const dates = Object.keys(paintMap.value)
+    if (!dates.length) {
+      ElMessage.warning('请先在日历上涂刷上班 / 休息日期')
+      return false
+    }
+    const months = new Set(dates.map((date) => date.slice(0, 7)))
+    if (months.size > 1) {
+      ElMessage.warning('涂刷范围跨越了多个月，一个方案只支持一个自然月，请清空后按月分别创建')
+      return false
+    }
+    return true
+  }
+  if (!form.date_range?.[0]) {
+    ElMessage.warning('请选择开始日期')
+    return false
+  }
+  if (!form.no_end && !form.date_range?.[1]) {
+    ElMessage.warning('请选择结束日期，或勾选「无期限」')
+    return false
+  }
+  if (!form.no_end && form.date_range[1] < form.date_range[0]) {
+    ElMessage.warning('结束日期不能早于开始日期')
+    return false
+  }
+  if (!form.weekdays.length) {
+    ElMessage.warning('请至少选择一个生效星期')
+    return false
+  }
+  return true
+}
+
+/* ---------------- 组装提交数据 ---------------- */
+
+function buildPayload() {
+  if (form.rule_mode === 'paint') return buildPaintPayload()
+  return {
+    plan_name: form.plan_name,
+    plan_type: form.plan_type,
+    shift_id: form.shift_id,
+    template_id: 0,
     template_code: '',
     template_name: '',
     align_mode: 0,
@@ -463,14 +1087,119 @@ function openCreate() {
     month_rest_days: 0,
     month_rest_weekday: 0,
     pattern: [],
+    scope_type: form.scope_type,
+    org_id: form.scope_type === 2 ? form.org_id : 0,
+    include_child: form.include_child,
+    employee_ids: form.scope_type === 3 ? form.employee_ids : [],
+    start_date: form.date_range?.[0],
+    // 无期限：结束日期留空，后端落哨兵值并按滚动窗口分批生成
+    end_date: form.no_end ? '' : form.date_range?.[1],
+    weekdays: form.weekdays,
+    note: form.note
+  }
+}
+
+// 涂排模式：把涂刷结果转成整月周期规则（align_mode=2 滚动顺延，周期=当月天数）
+// 班次时间全部来自班次管理中选中的班次
+function buildPaintPayload() {
+  const dates = Object.keys(paintMap.value)
+  if (!dates.length) return null
+  // 与顺延预览共用同一锚点：涂刷标记里最早的月份
+  const ym = paintBaseYm.value || dates[0].slice(0, 7)
+  const [start, end] = monthBounds(ym)
+  const lastDay = Number(end.slice(8, 10))
+  const shift = selectedShift.value
+  if (!shift) return null
+  const pattern = []
+  // 与画布展示同一套生效规则：显式标记为准，调休上班默认上班，
+  // 周末未标记默认休息，工作日未标记按休息处理（不再做周末延续继承）
+  for (let day = 1; day <= lastDay; day += 1) {
+    const dateText = `${ym}-${pad2(day)}`
+    const holiday = holidayMap.value[dateText] || null
+    const holidayType = holiday ? Number(holiday.type) : null
+    const weekday = weekdayOfDay(dateText)
+    const eff = resolveCellState(paintMap.value[dateText], holidayType, weekday).state
+    if (eff === 'work') {
+      pattern.push({
+        day_index: day - 1,
+        day_type: 1,
+        shift_id: shift.id,
+        shift_name: shift.name,
+        short_name: shift.short_name,
+        color: shift.color,
+        work_start: shift.work_start,
+        work_end: shift.work_end,
+        rest_start: shift.rest_start || '',
+        rest_end: shift.rest_end || '',
+        work_hours: shift.work_hours
+      })
+    } else {
+      pattern.push({
+        day_index: day - 1,
+        day_type: 2,
+        shift_id: 0,
+        shift_name: '',
+        short_name: '',
+        color: '#409EFF',
+        work_start: '',
+        work_end: '',
+        rest_start: '',
+        rest_end: '',
+        work_hours: 0
+      })
+    }
+  }
+  // 顺延：无期限时结束日期留空；否则滚动顺延到所选月份
+  const endDate = form.no_end ? '' : monthBounds(form.extend_month && form.extend_month > ym ? form.extend_month : ym)[1]
+  return {
+    plan_name: form.plan_name,
+    plan_type: form.plan_type,
+    shift_id: shift.id,
+    template_id: 0,
+    template_code: '',
+    template_name: `涂刷排班 ${ym}`,
+    align_mode: 2,
+    cycle_days: lastDay,
+    week_offset: 0,
+    month_rest_days: 0,
+    month_rest_weekday: 0,
+    pattern,
+    scope_type: form.scope_type,
+    org_id: form.scope_type === 2 ? form.org_id : 0,
+    include_child: form.include_child,
+    employee_ids: form.scope_type === 3 ? form.employee_ids : [],
+    start_date: start,
+    end_date: endDate,
+    weekdays: [],
+    note: form.note
+  }
+}
+
+/* ---------------- 打开 / 回显 ---------------- */
+
+function openCreate() {
+  editingID.value = 0
+  step.value = 1
+  isPainting.value = false
+  paintMonth.value = currentMonthText()
+  paintMap.value = {}
+  Object.assign(form, {
+    plan_name: '',
+    plan_type: 1,
+    rule_mode: 'paint',
+    tpl_id: null,
+    shift_id: shifts.value.find((item) => item.is_default === 1)?.id || shifts.value[0]?.id || null,
     scope_type: 2,
     org_id: null,
     include_child: true,
     employee_ids: [],
     date_range: [],
+    no_end: false,
     weekdays: [1, 2, 3, 4, 5],
+    extend_month: currentMonthText(),
     note: ''
   })
+  loadHolidays(Number(paintMonth.value.slice(0, 4)))
   formVisible.value = true
 }
 
@@ -478,176 +1207,78 @@ async function openEdit(row) {
   try {
     const detail = unwrap(await getSchedulePlanDetail(row.id)) || {}
     editingID.value = detail.id
-    preview.value = null
-    const isTemplate = Number(detail.align_mode) > 0 && Array.isArray(detail.pattern) && detail.pattern.length > 0
+    step.value = 1
+    isPainting.value = false
+    paintMap.value = {}
+    const isPattern = Number(detail.align_mode) > 0 && Array.isArray(detail.pattern) && detail.pattern.length > 0
+    const startYm = (detail.start_date || '').slice(0, 7)
+    const endYm = (detail.end_date || '').slice(0, 7)
+    const noEnd = Boolean(detail.no_end)
     Object.assign(form, {
       plan_name: detail.plan_name,
       plan_type: detail.plan_type,
-      rule_mode: isTemplate ? 'template' : 'weekday',
-      shift_id: detail.shift_id,
-      template_id: detail.template_id || null,
-      template_code: detail.template_code || '',
-      template_name: detail.template_name || '',
-      align_mode: detail.align_mode || 0,
-      cycle_days: detail.cycle_days || 0,
-      week_offset: detail.week_offset || 0,
-      month_rest_days: detail.month_rest_days || 0,
-      month_rest_weekday: detail.month_rest_weekday || 0,
-      pattern: isTemplate ? detail.pattern.map((item) => ({ ...item })) : [],
+      rule_mode: isPattern ? 'paint' : 'weekday',
+      tpl_id: null,
+      shift_id: detail.shift_id || null,
       scope_type: detail.scope_type,
       org_id: detail.org_id || null,
       include_child: detail.include_child === 1,
       employee_ids: detail.employee_ids || [],
-      date_range: [detail.start_date, detail.end_date],
-      weekdays: detail.weekdays || [],
+      // 无期限方案结束日期是哨兵值，回显时只保留开始日期
+      date_range: noEnd ? [detail.start_date].filter(Boolean) : [detail.start_date, detail.end_date].filter(Boolean),
+      no_end: noEnd,
+      weekdays: detail.weekdays?.length ? detail.weekdays : [1, 2, 3, 4, 5],
+      // 顺延月 = 结束月；无期限或哨兵值时退回开始月
+      extend_month:
+        noEnd || !endYm || endYm >= '2099-12'
+          ? startYm || currentMonthText()
+          : endYm,
       note: detail.note || ''
     })
-    currentTemplate.value = isTemplate
-      ? {
-          id: detail.template_id,
-          name: detail.template_name,
-          summary: '当前方案沿用调用时的模板规则（已复制到本方案，可继续调整）'
-        }
-      : null
+    if (isPattern) {
+      // 涂刷方案（滚动周期且周期长度=开始月天数）按开始月还原；
+      // 顺延 / 无期限只延长结束日期，不影响涂刷月，因此不再要求结束月与开始月相同
+      const align2 = Number(detail.align_mode) === 2
+      const daysInMonth = startYm ? Number(monthBounds(startYm)[1].slice(8, 10)) : 0
+      const matched = align2 && startYm && Number(detail.cycle_days) === daysInMonth && detail.pattern.length === daysInMonth
+      if (matched) {
+        paintMonth.value = startYm
+        detail.pattern.forEach((item) => {
+          if (Number(item.day_type) === 1) {
+            paintMap.value[`${startYm}-${pad2(Number(item.day_index) + 1)}`] = 'work'
+          }
+        })
+      } else {
+        // 非整月周期方案（如模板创建的大小周）：把周期按取模平铺到开始月，
+        // 让画布反映当前节奏，可继续自由调整后保存
+        paintMonth.value = startYm || currentMonthText()
+        fillPaintFromPattern(detail.pattern, Number(detail.cycle_days) || detail.pattern.length)
+        ElMessage.info(`已按当前方案周期（${detail.cycle_days} 天）平铺到 ${paintMonth.value}，可调整后保存`)
+      }
+      loadHolidays(Number(paintMonth.value.slice(0, 4)))
+    } else {
+      // 星期模式方案：切到涂排画布时按星期配置预填（见 rule_mode watch）
+      paintMonth.value = currentMonthText()
+    }
     formVisible.value = true
   } catch (error) {
     ElMessage.error(error.message || '加载方案失败')
   }
 }
 
-const weekdayLabels = ['周一', '周二', '周三', '周四', '周五', '周六', '周日']
-
-function patternLabel(index) {
-  if (form.align_mode === 3) return '上班日'
-  if (form.align_mode === 2) return `第 ${index + 1} 天`
-  const week = Math.floor(index / 7) + 1
-  const name = weekdayLabels[index % 7]
-  return form.cycle_days > 7 ? `第${week}周 ${name}` : name
-}
-
-function handleRuleModeChange(mode) {
-  preview.value = null
-  if (mode === 'weekday' && !form.shift_id) {
-    form.shift_id = shifts.value.find((item) => item.is_default === 1)?.id || shifts.value[0]?.id || null
-  }
-}
-
-// 选择模板：调用后端把模板规则复制成方案 pattern，同时自动匹配 / 创建班次
-async function handleTemplateChange(templateId) {
-  preview.value = null
-  if (!templateId) {
-    form.pattern = []
-    currentTemplate.value = null
-    return
-  }
-  try {
-    const data = unwrap(await applySchedTemplate(templateId)) || {}
-    const info = data.template || templates.value.find((item) => item.id === templateId) || {}
-    form.template_code = info.code || ''
-    form.template_name = info.name || ''
-    form.align_mode = info.align_mode || 0
-    form.cycle_days = info.cycle_days || 0
-    form.week_offset = info.week_offset || 0
-    form.month_rest_days = info.month_rest_days || 0
-    form.month_rest_weekday = info.month_rest_weekday || 0
-    form.pattern = (data.pattern || data.days || []).map((item) => ({ ...item }))
-    currentTemplate.value = { ...info, summary: info.summary || '' }
-    if (data.created_shift) {
-      ElMessage.success(`已套用模板，并自动创建 ${data.created_shift} 个班次`)
-      await loadShifts()
-    } else {
-      ElMessage.success('已套用模板规则')
-    }
-  } catch (error) {
-    ElMessage.error(error.message || '套用模板失败')
-  }
-}
-
-// 微调某天的班次：把班次快照带进 pattern，保存后与模板无关
-function applyShiftToPattern(row) {
-  const shift = shifts.value.find((item) => item.id === row.shift_id)
-  if (!shift) return
-  row.shift_name = shift.name
-  row.short_name = shift.short_name
-  row.color = shift.color
-  row.work_start = shift.work_start
-  row.work_end = shift.work_end
-  row.rest_start = shift.rest_start || ''
-  row.rest_end = shift.rest_end || ''
-  row.work_hours = shift.work_hours
-}
-
-function buildPayload() {
-  const templateMode = form.rule_mode === 'template'
-  return {
-    plan_name: form.plan_name,
-    plan_type: form.plan_type,
-    shift_id: templateMode ? 0 : form.shift_id,
-    template_id: templateMode ? form.template_id : 0,
-    template_code: templateMode ? form.template_code : '',
-    template_name: templateMode ? form.template_name : '',
-    align_mode: templateMode ? form.align_mode : 0,
-    cycle_days: templateMode ? form.cycle_days : 0,
-    week_offset: templateMode ? form.week_offset : 0,
-    month_rest_days: templateMode ? form.month_rest_days : 0,
-    month_rest_weekday: templateMode ? form.month_rest_weekday : 0,
-    pattern: templateMode ? form.pattern : [],
-    scope_type: form.scope_type,
-    org_id: form.scope_type === 2 ? form.org_id : 0,
-    include_child: form.include_child,
-    employee_ids: form.scope_type === 3 ? form.employee_ids : [],
-    start_date: form.date_range?.[0],
-    end_date: form.date_range?.[1],
-    weekdays: form.weekdays,
-    note: form.note
-  }
-}
-
-async function validateForm() {
-  if (!formRef.value) return false
-  const valid = await formRef.value.validate().catch(() => false)
-  if (!valid) return false
-  if (form.rule_mode === 'template') {
-    if (!form.template_id || form.pattern.length === 0) {
-      ElMessage.warning('请选择排班模板')
-      return false
-    }
-    if (!form.pattern.some((item) => item.day_type === 1)) {
-      ElMessage.warning('模板规则至少需要一天上班')
-      return false
-    }
-  } else if (!form.shift_id) {
-    ElMessage.warning('请选择班次')
-    return false
-  }
-  return true
-}
-
-async function runPreview() {
-  const valid = await validateForm()
-  if (!valid) return
-  previewing.value = true
-  try {
-    preview.value = unwrap(await previewSchedulePlan(buildPayload())) || {}
-  } catch (error) {
-    preview.value = null
-    ElMessage.error(error.message || '预览失败')
-  } finally {
-    previewing.value = false
-  }
-}
+/* ---------------- 保存 / 生成 ---------------- */
 
 async function savePlan() {
-  const valid = await validateForm()
-  if (!valid) return
+  if (!validateBasic()) return
+  if (!validateStrategy()) return
   saving.value = true
   try {
     if (editingID.value) {
       unwrap(await updateSchedulePlan(editingID.value, buildPayload()))
-      ElMessage.success('方案已更新，重新发布后新规则生效')
+      ElMessage.success('方案已更新，可在列表中「生成排班」下发')
     } else {
       unwrap(await createSchedulePlan(buildPayload()))
-      ElMessage.success('方案已保存，发布后生效')
+      ElMessage.success('方案已保存，可在列表中「生成排班」下发')
     }
     formVisible.value = false
     await loadPlans()
@@ -665,28 +1296,93 @@ async function handlePublishCommand(row, command) {
   if (command === 'overwrite') return publishPlan(row, true)
 }
 
-async function publishPlan(row, overwrite) {
+// 延续涂装：把涂刷规则按周期滚动顺延保存进方案（延伸方案的结束日期 /
+// 无期限），只存方案不下发，不动看板上已有的排班数据；
+// 后续由列表中的「生成排班」手动发布。
+const generating = ref(false)
+async function generateFromPaint() {
+  if (!validateBasic()) return
+  if (!validateStrategy()) return
+  generating.value = true
   try {
+    const payload = buildPayload()
+    const rangeText = form.no_end
+      ? `${payload.start_date} ~ 无期限（排班可生成到当年 12 月 31 日）`
+      : `${payload.start_date} ~ ${payload.end_date}`
+    // 涂刷基准月以实际标记为准（画布可能切到了其他月份）
+    const paintBaseMonth = paintBaseYm.value || paintMonth.value
+    const paintBaseText =
+      paintBaseMonth !== paintMonth.value
+        ? `以 ${paintBaseMonth} 涂刷为基准（画布当前在 ${paintMonth.value}），周期 ${payload.cycle_days} 天滚动顺延`
+        : `${paintMonthText.value} 涂刷，周期 ${payload.cycle_days} 天滚动顺延`
+    const strategyText = form.rule_mode === 'weekday' ? '按星期规则顺延' : paintBaseText
     await ElMessageBox.confirm(
-      overwrite
-        ? `将用方案「${row.plan_name}」覆盖范围内员工同一天的已有排班，是否继续？`
-        : `将按方案「${row.plan_name}」生成排班，已有排班的日期会被保留（不覆盖）。`,
-      overwrite ? '覆盖发布' : '发布排班',
-      { type: overwrite ? 'warning' : 'info', confirmButtonText: '发布' }
+      `<div class="gen-confirm">
+        <p>规则：<b>${strategyText}</b></p>
+        <p>方案区间：<b>${rangeText}</b></p>
+      </div>`,
+      '延续涂装保存',
+      { dangerouslyUseHTMLString: true, type: 'info', confirmButtonText: '保存方案', cancelButtonText: '取消' }
     )
+    if (editingID.value) {
+      unwrap(await updateSchedulePlan(editingID.value, payload))
+    } else {
+      const data = unwrap(await createSchedulePlan(payload)) || {}
+      // 回填新建方案的 ID，之后继续点击「延续涂装」走更新而不是重复建方案
+      editingID.value = data?.plan?.id || 0
+    }
+    ElMessage.success('方案已延续保存，后续月份按周期滚动顺延（画布已切换到顺延首月预览）；下发请到方案列表点「生成排班」')
+    // 留在表单里，并把画布翻到顺延首月，直观看到滚动结果
+    if (payload.cycle_days > 0 && (form.no_end || (form.extend_month && form.extend_month > paintBaseMonth))) {
+      const [baseYear, baseMonth] = paintBaseMonth.split('-').map(Number)
+      const nextYm = baseMonth === 12 ? `${baseYear + 1}-01` : `${baseYear}-${pad2(baseMonth + 1)}`
+      if (paintMonth.value !== nextYm) {
+        paintMonth.value = nextYm
+        loadHolidays(Number(nextYm.slice(0, 4)))
+      }
+    }
+    await loadPlans()
+    emit('changed')
+  } catch (error) {
+    if (error !== 'cancel' && error !== 'close') {
+      ElMessage.error(error.message || '延续涂装保存失败')
+    }
+  } finally {
+    generating.value = false
+  }
+}
+
+// 列表行操作：批量生成排班（保留已有） / 覆盖发布
+async function publishPlan(row, overwrite) {
+  const isGen = !overwrite
+  const title = isGen ? '批量生成排班' : '覆盖发布'
+  const message = isGen
+    ? `将按方案「${row.plan_name}」批量生成排班，已有排班的日期会被保留（不覆盖），是否继续？`
+    : `将用方案「${row.plan_name}」覆盖范围内员工同一天的已有排班，是否继续？`
+  try {
+    await ElMessageBox.confirm(message, title, {
+      type: overwrite ? 'warning' : 'info',
+      confirmButtonText: isGen ? '确认生成' : '覆盖发布'
+    })
   } catch {
     return
   }
   try {
     const data = unwrap(await publishSchedulePlan(row.id, { overwrite })) || {}
     const stats = data.publish || {}
-    ElMessage.success(
-      `发布完成：新增 ${stats.created || 0} 条，覆盖 ${stats.updated || 0} 条，跳过 ${stats.skipped || 0} 条`
-    )
+    if (isGen) {
+      ElMessage.success(
+        `生成完成：新增 ${stats.created || 0} 条，跳过 ${stats.skipped || 0} 条，覆盖 ${stats.updated || 0} 条`
+      )
+    } else {
+      ElMessage.success(
+        `发布完成：新增 ${stats.created || 0} 条，覆盖 ${stats.updated || 0} 条，跳过 ${stats.skipped || 0} 条`
+      )
+    }
     await loadPlans()
     emit('changed')
   } catch (error) {
-    ElMessage.error(error.message || '发布失败')
+    ElMessage.error(error.message || (overwrite ? '发布失败' : '生成排班失败'))
   }
 }
 
@@ -726,7 +1422,7 @@ function ruleText(row) {
   return weekdayText(row.weekdays)
 }
 
-defineExpose({ loadPlans })
+defineExpose({ loadPlans, reloadShifts: loadShifts })
 </script>
 
 <style scoped lang="less">
@@ -735,87 +1431,340 @@ defineExpose({ loadPlans })
   align-items: center;
   justify-content: space-between;
   gap: 12px;
-  margin-bottom: 12px;
+  margin-bottom: 10px;
 }
 .plan-tip {
   color: #909399;
-  font-size: 13px;
+  font-size: 12px;
 }
 .plan-toolbar-actions {
   display: flex;
   align-items: center;
   gap: 8px;
 }
-.shift-dot {
-  display: inline-block;
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  margin-right: 6px;
-}
-.ml2 {
-  margin-left: 2px;
-}
 .pagination {
   display: flex;
   justify-content: flex-end;
   margin-top: 10px;
 }
+.shift-dot {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  margin-right: 4px;
+  border-radius: 50%;
+}
+.ml2 {
+  margin-left: 2px;
+}
+
 .plan-form-head {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  margin-bottom: 12px;
+  margin-bottom: 8px;
 }
 .form-title {
+  font-size: 15px;
   font-weight: 600;
+  color: #303133;
 }
+.plan-steps {
+  margin-bottom: 16px;
+  padding: 8px 0;
+
+  :deep(.el-step) {
+    cursor: pointer;
+  }
+}
+
 .form-grid {
   display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 0 16px;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  column-gap: 16px;
+}
+.form-grid > .el-form-item {
+  margin-bottom: 14px;
 }
 .scope-row {
-  grid-template-columns: 2fr 1fr;
+  grid-template-columns: minmax(0, 1.4fr) minmax(0, 1fr);
 }
-.preview-box {
+
+.shift-select-wrap {
+  width: 100%;
+}
+.shift-select-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+}
+.shift-meta {
+  display: inline-block;
+  margin-top: 2px;
+  font-size: 12px;
+  color: #909399;
+}
+.shift-empty-alert {
+  margin-bottom: 12px;
+}
+.shift-empty-body {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 10px;
   margin-top: 4px;
 }
-.preview-employees {
+
+/* 步骤 2：按月涂排 */
+.paint-tip {
+  padding: 8px 12px;
+  font-size: 12px;
+  line-height: 18px;
+  color: #909399;
+  background: #fafcff;
+  border-bottom: 1px solid #ebeef5;
+}
+
+.paint-canvas {
+  border: 1px solid #e4e7ed;
+  border-radius: 6px;
+  overflow: hidden;
+}
+.paint-month-bar {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 8px 12px;
+  background: #f5f7fa;
+  border-bottom: 1px solid #e4e7ed;
+}
+.paint-month {
+  font-size: 13px;
+  font-weight: 600;
+  color: #303133;
+}
+.paint-stats {
+  margin-left: auto;
+  font-size: 12px;
+  color: #909399;
+
+  strong {
+    color: #303133;
+  }
+}
+.paint-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 12px;
+  border-bottom: 1px solid #ebeef5;
+}
+.paint-extend-label {
+  font-size: 12px;
+  color: #606266;
+}
+.paint-extend-hint {
+  font-size: 11px;
+  color: #c0c4cc;
+}
+
+.timeline-week {
+  display: grid;
+  grid-template-columns: repeat(7, minmax(0, 1fr));
+  background: #fff;
+  border-bottom: 1px solid #ebeef5;
+
+  span {
+    padding: 6px 0;
+    text-align: center;
+    font-size: 12px;
+    color: #909399;
+  }
+}
+.timeline-grid {
+  display: grid;
+  grid-template-columns: repeat(7, minmax(0, 1fr));
+  background: #ebeef5;
+  gap: 1px;
+}
+
+// 延续状态的日期：虚线弱化显示，与手动涂刷区分
+.timeline-cell.is-inherited {
+  outline: 1px dashed #a0cfff;
+  outline-offset: -3px;
+  opacity: 0.82;
+}
+.inh-tag {
+  margin-left: 3px;
+  padding: 0 3px;
+  border-radius: 3px;
+  background: #f4f4f5;
+  color: #909399;
+  font-size: 10px;
+  font-style: normal;
+}
+.paint-grid {
+  user-select: none;
+  cursor: pointer;
+}
+.timeline-cell {
+  min-height: 64px;
+  padding: 6px;
+  background: #fff;
+  font-size: 12px;
+  color: #606266;
+
+  &.is-blank {
+    background: #fafafa;
+    cursor: default;
+  }
+  &.is-work {
+    background: #ecf5ff;
+  }
+  &.is-rest-painted {
+    background: #f4f4f5;
+  }
+  &.is-unset {
+    background: #fff;
+  }
+  &.is-weekend {
+    background: #fdf6ec;
+  }
+  &.is-holiday-off {
+    background: #fff5f5;
+  }
+  &.is-holiday-work {
+    background: #f4f4f5;
+  }
+}
+.cell-date {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  font-weight: 600;
+  color: #303133;
+}
+.cell-tags {
+  display: flex;
+  gap: 3px;
+}
+.cell-tag {
+  padding: 0 4px;
+  border-radius: 3px;
+  font-size: 10px;
+  line-height: 15px;
+  font-weight: 400;
+
+  &.is-off {
+    background: #fef0f0;
+    color: #f56c6c;
+  }
+  &.is-workday {
+    background: #f4f4f5;
+    color: #909399;
+  }
+  &.is-weekend {
+    background: #fdf6ec;
+    color: #e6a23c;
+  }
+  &.is-today {
+    background: #ecf5ff;
+    color: #409eff;
+  }
+}
+.cell-shift {
+  margin-top: 4px;
+  line-height: 16px;
+
+  &.muted {
+    color: #c0c4cc;
+  }
+  &.is-rest-text {
+    color: #909399;
+  }
+}
+.cell-shift-name {
+  display: block;
+  color: #409eff;
+  font-weight: 600;
+}
+.cell-shift-time {
+  display: block;
+  color: #909399;
+  font-size: 11px;
+}
+.cell-holiday-name {
+  margin-top: 2px;
+  font-size: 11px;
+  color: #f56c6c;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.timeline-legend {
   display: flex;
   flex-wrap: wrap;
-  gap: 6px;
-  margin-top: 10px;
-}
-.more-tip {
-  color: #909399;
+  gap: 12px;
+  padding: 6px 12px;
+  background: #fafafa;
+  border-top: 1px solid #ebeef5;
   font-size: 12px;
-  line-height: 24px;
+  color: #909399;
+
+  span {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+  }
 }
+.dot {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 2px;
+
+  &.is-work-dot {
+    background: #409eff;
+  }
+  &.is-rest-dot {
+    background: #e4e7ed;
+  }
+  &.is-unset-dot {
+    background: #fff;
+    border: 1px solid #dcdfe6;
+  }
+  &.is-weekend-dot {
+    background: #e6a23c;
+  }
+  &.is-holiday-dot {
+    background: #f56c6c;
+  }
+}
+
+/* 按星期模式 */
+.date-noend-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+.date-sep {
+  color: #909399;
+}
+.weekday-tip {
+  margin-top: -6px;
+  padding-left: 92px;
+  font-size: 12px;
+  color: #909399;
+}
+
 .form-actions {
   display: flex;
   justify-content: flex-end;
-  gap: 10px;
-  margin-top: 16px;
-}
-.template-row {
-  grid-template-columns: 1fr 1fr;
-}
-.template-summary {
-  color: #909399;
-  font-size: 13px;
-  line-height: 32px;
-}
-.pattern-table {
-  margin-top: 4px;
-}
-.pattern-tip {
-  margin-top: 6px;
-  color: #909399;
-  font-size: 12px;
-}
-.rest-text {
-  color: #c0c4cc;
-  font-size: 12px;
+  gap: 8px;
+  margin-top: 14px;
+  padding-top: 10px;
+  border-top: 1px solid #ebeef5;
 }
 </style>
diff --git a/backend/src/views/apps/oa/scheduling/index.vue b/backend/src/views/apps/oa/scheduling/index.vue
index c442206..276b274 100644
--- a/backend/src/views/apps/oa/scheduling/index.vue
+++ b/backend/src/views/apps/oa/scheduling/index.vue
@@ -58,17 +58,23 @@
         />
         <el-tree-select
           v-model="filters.org_id"
-          :data="orgTree"
+          :data="orgFilterTree"
           :props="{ label: 'org_name', value: 'id', children: 'children' }"
           node-key="id"
           check-strictly
+          :render-after-expand="false"
+          default-expand-all
           filterable
-          clearable
-          placeholder="全部组织"
+          :clearable="false"
+          placeholder="全部"
           style="width: 200px"
           @change="loadBoard"
         />
-        <el-checkbox v-model="filters.include_child" @change="loadBoard">含下级组织</el-checkbox>
+        <el-checkbox
+          v-model="filters.include_child"
+          :disabled="!filters.org_id"
+          @change="loadBoard"
+        >含下级组织</el-checkbox>
         <el-input
           v-model="filters.keyword"
           placeholder="搜索员工姓名 / 账号"
@@ -78,6 +84,13 @@
         />
         <el-checkbox v-model="filters.only_scheduled">只看有排班</el-checkbox>
         <el-button :icon="Refresh" @click="loadBoard">刷新</el-button>
+        <el-button
+          :type="batchMode ? 'warning' : 'default'"
+          @click="toggleBatchMode"
+        >{{ batchMode ? "退出批量" : "批量编辑" }}</el-button>
+        <el-button :icon="Download" :disabled="!displayEmployees.length" @click="exportBoard">
+          导出{{ exportCount ? ` ${exportCount} 人` : "全部" }}
+        </el-button>
         <div class="legend">
           <span v-for="shift in shifts" :key="shift.id" class="legend-item">
             <span class="legend-dot" :style="{ background: shift.color }" />{{ shift.short_name || shift.name }}
@@ -85,41 +98,67 @@
         </div>
       </div>
 
-      <div class="board-wrap" :class="{ 'is-month': isMonth }" v-loading="loading">
+      <!-- 批量选择操作条 -->
+      <div v-if="batchMode" class="batch-bar">
+        <span class="batch-tip">按住拖动连续选中，单击切换选中（员工 × 日期格子）</span>
+        <span v-if="selectedCount" class="batch-count">
+          已选 <b>{{ selectedCount }}</b> 格 · <b>{{ selectedEmployees.length }}</b> 人 · <b>{{ selectedDates.length }}</b> 天
+        </span>
+        <span v-else class="batch-count muted">尚未选择</span>
+        <el-button size="small" type="primary" :disabled="!selectedCount" @click="openBatchEntry">批量编辑所选</el-button>
+        <el-button size="small" :disabled="!selectedCount" @click="clearBatchSelection">清空选择</el-button>
+      </div>
+
+      <div class="board-wrap" :class="{ 'is-month': isMonth, 'batch-mode': batchMode }" v-loading="loading">
         <table v-if="displayEmployees.length" class="board-table">
           <thead>
             <tr>
-              <th class="sticky-col">员工</th>
+              <th class="sticky-col check-col">
+                <label class="export-all" title="全选 / 清空；导出时不勾选默认导出全部">
+                  <input type="checkbox" :checked="exportAllChecked" @change="toggleExportAll" />
+                </label>
+              </th>
+              <th class="sticky-col emp-col">员工</th>
               <th
                 v-for="day in dateCells"
                 :key="day.date"
                 :class="{
                   'is-today': day.is_today,
-                  'is-holiday': holidayOf(day.date)?.type === 1,
-                  'is-makeup': holidayOf(day.date)?.type === 0
+                  'is-holiday-off': holidayOf(day.date)?.type === 1,
+                  'is-holiday-work': holidayOf(day.date)?.type === 0,
+                  'is-weekend': isWeekendDay(day) && !holidayOf(day.date)
                 }"
               >
                 <div class="date-main">{{ day.date.slice(5) }}</div>
                 <div class="date-sub">{{ weekdayLabel(day.weekday) }}</div>
                 <div
-                  v-if="holidayOf(day.date)"
+                  v-if="cellDayLabel(day)"
                   class="date-holiday"
-                  :title="holidayOf(day.date).name"
+                  :title="cellDayLabel(day).name"
                 >
                   <span
                     class="holiday-tag"
-                    :class="holidayOf(day.date).type === 1 ? 'is-off' : 'is-work'"
+                    :class="cellDayLabel(day).cls"
                   >
-                    {{ holidayOf(day.date).type === 1 ? "休" : "班" }}
+                    {{ cellDayLabel(day).tag }}
                   </span>
-                  <span v-if="!isMonth" class="holiday-name">{{ holidayOf(day.date).name }}</span>
+                  <span v-if="!isMonth" class="holiday-name">{{ cellDayLabel(day).name }}</span>
                 </div>
               </th>
             </tr>
           </thead>
           <tbody>
             <tr v-for="employee in displayEmployees" :key="employee.id">
-              <td class="sticky-col employee-cell">
+              <td class="sticky-col check-col">
+                <input
+                  type="checkbox"
+                  class="emp-check"
+                  :checked="!!exportSel[employee.id]"
+                  @click.stop
+                  @change="exportSel[employee.id] = $event.target.checked"
+                />
+              </td>
+              <td class="sticky-col emp-col employee-cell">
                 <div class="emp-name">{{ employee.name }}</div>
                 <div class="emp-meta">{{ employee.org_name || "未分配部门" }}</div>
               </td>
@@ -127,13 +166,21 @@
                 v-for="day in dateCells"
                 :key="day.date"
                 class="shift-cell"
-                :class="{ 'is-today': day.is_today }"
-                @click="openCell(employee, day.date)"
+                :class="{
+                  'is-today': day.is_today,
+                  'is-holiday-off': holidayOf(day.date)?.type === 1,
+                  'is-holiday-work': holidayOf(day.date)?.type === 0,
+                  'is-weekend': isWeekendDay(day) && !holidayOf(day.date),
+                  'is-selected': batchMode && selection[`${employee.id}|${day.date}`]
+                }"
+                @mousedown="batchMode && batchMouseDown($event)"
+                @mouseover="batchMode && batchMouseOver(employee.id, day.date)"
+                @click="batchMode ? batchClick(employee.id, day.date) : openCell(employee, day.date)"
               >
                 <div
                   v-if="employee.days[day.date]"
                   class="shift-block"
-                  :style="shiftStyle(employee.days[day.date])"
+                  :style="shiftStyle(employee.days[day.date], day.is_today)"
                   :title="cellTitle(employee.days[day.date])"
                 >
                   <span v-if="employee.days[day.date].source === 2" class="temp-flag">临</span>
@@ -155,14 +202,24 @@
       </div>
     </div>
 
-    <shift-dialog v-model="shiftVisible" @changed="loadBoard" />
-    <plan-dialog v-model="planVisible" @changed="loadBoard" />
+    <shift-dialog v-model="shiftVisible" @changed="handleShiftChanged" />
+    <plan-dialog
+      ref="planDialogRef"
+      v-model="planVisible"
+      @changed="loadBoard"
+      @open-shifts="openShiftDialog"
+    />
     <entry-dialog
       v-model="entryVisible"
       :preset-employee-ids="entryPreset.employeeIds"
       :preset-date="entryPreset.date"
       @changed="handleEntryChanged"
     />
+    <batch-dialog
+      v-model="batchVisible"
+      :cells="batchCells"
+      @changed="handleBatchChanged"
+    />
     <swap-dialog
       v-model="swapVisible"
       :entry="selectedCell.entry"
@@ -199,8 +256,8 @@
 </template>
 
 <script setup>
-import { computed, onMounted, reactive, ref } from 'vue'
-import { ArrowLeft, ArrowRight, Clock, Plus, Refresh, Right, Search, Setting, Tickets } from '@element-plus/icons-vue'
+import { computed, onBeforeUnmount, onMounted, reactive, ref } from 'vue'
+import { ArrowLeft, ArrowRight, Clock, Download, Plus, Refresh, Right, Search, Setting, Tickets } from '@element-plus/icons-vue'
 import { ElMessage } from 'element-plus'
 import { oaOrganizationApi } from '@/api/organization'
 import { buildOrgTree } from '@/views/apps/organization/composables'
@@ -210,6 +267,7 @@ import ShiftDialog from './components/shiftDialog.vue'
 import PlanDialog from './components/planDialog.vue'
 import EntryDialog from './components/entryDialog.vue'
 import SwapDialog from './components/swapDialog.vue'
+import BatchDialog from './components/batchDialog.vue'
 
 const WEEK_LABELS = { 1: '周一', 2: '周二', 3: '周三', 4: '周四', 5: '周五', 6: '周六', 7: '周日' }
 
@@ -244,9 +302,14 @@ const truncated = ref(false)
 const board = ref({ employees: [], dates: [], summary: {}, shifts: [] })
 const shifts = ref([])
 const orgTree = ref([])
-const filters = reactive({ org_id: null, include_child: true, keyword: '', only_scheduled: false })
+// 组织筛选树：「全部」根节点 + 完整组织架构，默认显示全部
+const orgFilterTree = computed(() => [
+  { id: 0, org_name: '全部', children: orgTree.value }
+])
+const filters = reactive({ org_id: 0, include_child: true, keyword: '', only_scheduled: false })
 
 const shiftVisible = ref(false)
+const planDialogRef = ref(null)
 const planVisible = ref(false)
 const entryVisible = ref(false)
 const swapVisible = ref(false)
@@ -256,6 +319,136 @@ const changesLoading = ref(false)
 const entryPreset = reactive({ employeeIds: [], date: '' })
 const selectedCell = reactive({ entry: null, employeeId: 0, employeeName: '', scheduleDate: '' })
 
+// ===== 批量编辑：员工 × 日期格子的多选 =====
+const batchMode = ref(false)
+const selection = reactive({})
+const batchDragging = ref(false)
+const batchDragMoved = ref(false)
+const batchVisible = ref(false)
+
+const selectedKeys = computed(() => Object.keys(selection).filter((key) => selection[key]))
+const selectedCount = computed(() => selectedKeys.value.length)
+const selectedEmployees = computed(() => [...new Set(selectedKeys.value.map((key) => Number(key.split('|')[0])))])
+const selectedDates = computed(() => [...new Set(selectedKeys.value.map((key) => key.split('|')[1]))].sort())
+
+function toggleBatchMode() {
+  batchMode.value = !batchMode.value
+  if (batchMode.value) {
+    ElMessage.info('批量模式：按住拖动连续选中格子，单击切换选中，选完后点「批量编辑所选」')
+  } else {
+    clearBatchSelection()
+  }
+}
+
+function clearBatchSelection() {
+  Object.keys(selection).forEach((key) => {
+    delete selection[key]
+  })
+}
+
+// ===== 导出：员工行勾选（不勾选 = 导出全部）=====
+const exportSel = reactive({})
+const exportCount = computed(() => displayEmployees.value.filter((e) => exportSel[e.id]).length)
+const exportAllChecked = computed(
+  () => displayEmployees.value.length > 0 && exportCount.value === displayEmployees.value.length
+)
+
+function toggleExportAll() {
+  const all = displayEmployees.value
+  if (exportAllChecked.value) {
+    all.forEach((e) => {
+      delete exportSel[e.id]
+    })
+  } else {
+    all.forEach((e) => {
+      exportSel[e.id] = true
+    })
+  }
+}
+
+async function exportBoard() {
+  const all = displayEmployees.value
+  if (!all.length) {
+    ElMessage.warning('当前没有可导出的排班数据')
+    return
+  }
+  const list = exportCount.value ? all.filter((e) => exportSel[e.id]) : all
+  const days = dateCells.value
+  if (!days.length) {
+    ElMessage.warning('当前没有日期范围')
+    return
+  }
+  const XLSX = await import('xlsx')
+  const header = [
+    '员工',
+    '部门',
+    ...days.map((d) => `${d.date.slice(5).replace('-', '/')} ${weekdayLabel(d.weekday)}`)
+  ]
+  const rows = list.map((emp) => [
+    emp.name,
+    emp.org_name || '',
+    ...days.map((d) => {
+      const entry = emp.days[d.date]
+      if (!entry) return ''
+      const name = entry.short_name || entry.shift_name || ''
+      return entry.source === 2 ? `${name}(临)` : name
+    })
+  ])
+  const ws = XLSX.utils.aoa_to_sheet([header, ...rows])
+  ws['!cols'] = [{ wch: 10 }, { wch: 18 }, ...days.map(() => ({ wch: 8 }))]
+  const wb = XLSX.utils.book_new()
+  XLSX.utils.book_append_sheet(wb, ws, '排班表')
+  const range = `${days[0].date}_${days[days.length - 1].date}`
+  XLSX.writeFile(wb, `排班表_${range}.xlsx`)
+  ElMessage.success(`已导出 ${list.length} 名员工、${days.length} 天的排班`)
+}
+
+function batchMouseDown(event) {
+  event.preventDefault()
+  batchDragging.value = true
+  batchDragMoved.value = false
+}
+
+function batchMouseOver(employeeId, date) {
+  if (!batchDragging.value) return
+  batchDragMoved.value = true
+  selection[`${employeeId}|${date}`] = true
+}
+
+function batchClick(employeeId, date) {
+  // 拖动结束的 click 不做切换，只有真正的单击才切换选中
+  if (batchDragMoved.value) return
+  const key = `${employeeId}|${date}`
+  if (selection[key]) delete selection[key]
+  else selection[key] = true
+}
+
+function onWindowMouseUp() {
+  batchDragging.value = false
+}
+
+// 选中的格子集合：[{ employee_id, employee_name, date }]
+const batchCells = computed(() => {
+  const names = {}
+  board.value.employees.forEach((item) => {
+    names[item.id] = item.name
+  })
+  return selectedKeys.value.map((key) => {
+    const [id, date] = key.split('|')
+    return { employee_id: Number(id), employee_name: names[Number(id)] || '', date }
+  })
+})
+
+function openBatchEntry() {
+  if (!selectedCount.value) return
+  batchVisible.value = true
+}
+
+function handleBatchChanged() {
+  clearBatchSelection()
+  loadBoard()
+}
+
 const summary = computed(() => board.value.summary || {})
 const dateCells = computed(() => board.value.dates || [])
 const rangeText = computed(() => {
@@ -280,21 +473,27 @@ function cellTitle(entry) {
   return parts.join(' ')
 }
 
-function shiftStyle(entry) {
+function shiftStyle(entry, isToday) {
+  // 按当前班次定义统一取色，避免不同时期生成的记录颜色快照不一致
+  const def = shifts.value.find((s) => s.id === entry.shift_id)
+  const color = (def && def.color) || entry.color || '#409EFF'
   return {
-    borderLeftColor: entry.color || '#409EFF',
-    background: hexToRgba(entry.color || '#409EFF', 0.1),
+    borderLeftColor: color,
+    // 不透明预混色：今天列混绿底，其余混白底，避免半透明叠加周末/节假日底色混色
+    background: mixColor(color, 0.1, isToday ? '#e4f5d2' : '#ffffff'),
     color: '#303133'
   }
 }
 
-function hexToRgba(hex, alpha) {
-  const value = String(hex || '').replace('#', '')
-  if (value.length !== 6) return `rgba(64, 158, 255, ${alpha})`
-  const r = parseInt(value.slice(0, 2), 16)
-  const g = parseInt(value.slice(2, 4), 16)
-  const b = parseInt(value.slice(4, 6), 16)
-  return `rgba(${r}, ${g}, ${b}, ${alpha})`
+// hex 颜色按比例混入基色，返回不透明色
+function mixColor(hex, ratio, base) {
+  const v = String(hex || '').replace('#', '')
+  const b = String(base || '#ffffff').replace('#', '')
+  if (v.length !== 6 || b.length !== 6) return '#ecf5ff'
+  const ch = (s, i) => parseInt(s.slice(i, i + 2), 16)
+  const mix = (i) => Math.round(ratio * ch(v, i) + (1 - ratio) * ch(b, i))
+  const to = (n) => n.toString(16).padStart(2, '0')
+  return `#${to(mix(0))}${to(mix(2))}${to(mix(4))}`
 }
 
 async function loadOrgTree() {
@@ -354,6 +553,26 @@ function holidayOf(date) {
   return holidayMap.value[date] || null
 }
 
+function isWeekendDay(day) {
+  // 法定节假日/调休优先（holidayMap 已覆盖），未标记时按周六=6、周日=7
+  if (!day) return false
+  return day.weekday === 6 || day.weekday === 7
+}
+
+function cellHolidayType(date) {
+  // 返回 1=法定放假(休) 0=调休上班(班) null=无
+  const h = holidayOf(date)
+  return h ? Number(h.type) : null
+}
+
+function cellDayLabel(day) {
+  if (!day) return null
+  const h = holidayOf(day.date)
+  if (h) return h.type === 1 ? { tag: '休', cls: 'is-off', name: h.name } : { tag: '班', cls: 'is-work', name: h.name }
+  if (isWeekendDay(day)) return { tag: '休', cls: 'is-off-weekend', name: day.weekday === 6 ? '周六' : '周日' }
+  return null
+}
+
 async function loadBoard() {
   loading.value = true
   try {
@@ -442,6 +661,17 @@ function handleEntryChanged() {
   loadBoard()
 }
 
+// 排班方案里提示「没有班次」时，直接打开班次管理弹窗
+function openShiftDialog() {
+  shiftVisible.value = true
+}
+
+// 班次管理变更后，同步刷新方案弹窗的班次列表
+function handleShiftChanged() {
+  loadBoard()
+  planDialogRef.value?.reloadShifts?.()
+}
+
 async function openChanges() {
   changesVisible.value = true
   await loadChanges()
@@ -467,9 +697,14 @@ async function loadChanges() {
 }
 
 onMounted(async () => {
+  window.addEventListener('mouseup', onWindowMouseUp)
   await Promise.all([loadOrgTree(), loadShifts()])
   await loadBoard()
 })
+
+onBeforeUnmount(() => {
+  window.removeEventListener('mouseup', onWindowMouseUp)
+})
 </script>
 
 <style scoped lang="less">
@@ -505,20 +740,8 @@ onMounted(async () => {
 }
 .stat-card {
   padding: 15px 18px;
-  background: #fff;
-  border: 1px solid #ebeef5;
-  border-top: 3px solid #409eff;
+  background: #f7f8fa;
   border-radius: 8px;
-
-  &.purple {
-    border-top-color: #8b5cf6;
-  }
-  &.green {
-    border-top-color: #67c23a;
-  }
-  &.orange {
-    border-top-color: #e6a23c;
-  }
 }
 .stat-label,
 .stat-sub {
@@ -571,6 +794,37 @@ onMounted(async () => {
   max-height: 640px;
   border: 1px solid #ebeef5;
   border-radius: 6px;
+
+  // 批量模式：格子进入可选状态，禁止拖蓝
+  &.batch-mode .shift-cell {
+    cursor: cell;
+    user-select: none;
+  }
+}
+.batch-bar {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+  padding: 8px 12px;
+  margin-bottom: 8px;
+  background: #fdf6ec;
+  border: 1px solid #f3d19e;
+  border-radius: 6px;
+  font-size: 12px;
+  color: #b88230;
+
+  .batch-tip {
+    color: #b88230;
+  }
+  .batch-count {
+    b {
+      color: #c05621;
+    }
+    &.muted {
+      color: #d0a96a;
+    }
+  }
 }
 .board-table {
   width: 100%;
@@ -594,7 +848,10 @@ onMounted(async () => {
     padding: 8px 4px;
   }
   thead th.is-today {
-    background: #ecf5ff;
+    background: #d9f0c7;
+    .date-main {
+      color: #3d8b1e;
+    }
   }
   .date-main {
     font-size: 13px;
@@ -605,10 +862,16 @@ onMounted(async () => {
     font-size: 12px;
     color: #909399;
   }
-  // 法定假日表头：浅红底 + 「休」角标；调休上班日标「班」
-  thead th.is-holiday:not(.is-today) {
+  // 法定假日表头：浅红底；调休上班：灰底；周末：淡橙底（周末节假日优先用节假日样式）
+  thead th.is-holiday-off:not(.is-today) {
     background: #fffafa;
   }
+  thead th.is-holiday-work:not(.is-today) {
+    background: #f5f7fa;
+  }
+  thead th.is-weekend:not(.is-today) {
+    background: #fdf6ec;
+  }
   .date-holiday {
     display: flex;
     align-items: center;
@@ -639,6 +902,11 @@ onMounted(async () => {
       color: #909399;
       border: 1px solid #e9e9eb;
     }
+    &.is-off-weekend {
+      background: #fdf6ec;
+      color: #e6a23c;
+      border: 1px solid #faecd8;
+    }
   }
   .holiday-name {
     font-size: 11px;
@@ -646,21 +914,55 @@ onMounted(async () => {
     overflow: hidden;
     text-overflow: ellipsis;
     white-space: nowrap;
+
+    .is-off-weekend ~ &,
+    &.is-off-weekend-name {
+      color: #e6a23c;
+    }
   }
   .sticky-col {
     position: sticky;
-    left: 0;
     z-index: 1;
-    width: 150px;
-    min-width: 150px;
     background: #fff;
-    text-align: left;
-    padding: 8px 12px;
     border-right: 1px solid #ebeef5;
+
+    &.check-col {
+      left: 0;
+      width: 42px;
+      min-width: 42px;
+      padding: 8px 0;
+      text-align: center;
+
+      .emp-check {
+        cursor: pointer;
+        accent-color: #409eff;
+      }
+    }
+    &.emp-col {
+      left: 42px;
+      width: 150px;
+      min-width: 150px;
+      text-align: center;
+      padding: 8px 10px;
+    }
   }
   thead .sticky-col {
     z-index: 3;
     background: #f5f7fa;
+
+    .export-all {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 6px;
+      cursor: pointer;
+      user-select: none;
+
+      input {
+        cursor: pointer;
+        accent-color: #409eff;
+      }
+    }
   }
   .employee-cell {
     .emp-name {
@@ -679,25 +981,42 @@ onMounted(async () => {
     min-width: 118px;
     height: 56px;
     cursor: pointer;
-    padding: 4px;
+    padding: 0 3px;
 
     &.is-today {
-      background: #f7fbff;
+      background: #e4f5d2;
+    }
+    &.is-holiday-off:not(.is-today) {
+      background: #fffafa;
+    }
+    &.is-holiday-work:not(.is-today) {
+      background: #fafbfc;
+    }
+    &.is-weekend:not(.is-today) {
+      background: #fdf6ec;
     }
     &:hover {
       background: #f5f7fa;
     }
+    // 批量模式选中格
+    &.is-selected {
+      background: #ecf5ff;
+      outline: 2px solid #409eff;
+      outline-offset: -2px;
+    }
   }
   .shift-block {
     position: relative;
     display: flex;
     flex-direction: column;
-    align-items: flex-start;
+    align-items: center;
+    justify-content: center;
     gap: 2px;
-    padding: 5px 7px;
-    border-left: 3px solid #409eff;
+    padding: 2px 6px;
+    height: 100%;
+    box-sizing: border-box;
     border-radius: 4px;
-    text-align: left;
+    text-align: center;
     min-height: 38px;
   }
   .shift-title {
@@ -726,7 +1045,10 @@ onMounted(async () => {
   .empty-cell {
     color: #dcdfe6;
     font-size: 16px;
-    line-height: 38px;
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
   }
 }
 
@@ -738,22 +1060,21 @@ onMounted(async () => {
     thead th {
       padding: 6px 2px;
     }
-    .sticky-col {
+    .sticky-col.emp-col {
       width: 130px;
       min-width: 130px;
-      padding: 6px 10px;
+      padding: 6px 8px;
     }
     .shift-cell {
       width: 54px;
       min-width: 54px;
       height: 42px;
-      padding: 2px;
+      padding: 0 2px;
     }
     .shift-block {
       gap: 1px;
-      padding: 3px 4px;
-      min-height: 30px;
-      border-left-width: 2px;
+      padding: 2px 4px;
+      min-height: 100%;
     }
     .shift-title {
       font-size: 11px;
@@ -818,8 +1139,7 @@ html.dark & {
     color: var(--el-text-color-secondary);
   }
   .stat-card {
-    background: var(--el-bg-color);
-    border-color: var(--el-border-color-lighter);
+    background: var(--el-fill-color-light);
 
     .stat-label,
     .stat-sub {
@@ -846,11 +1166,17 @@ html.dark & {
       background: var(--el-fill-color-light);
     }
     thead th.is-today {
-      background: var(--el-color-primary-light-9);
+      background: rgba(103, 194, 58, 0.26);
     }
-    thead th.is-holiday:not(.is-today) {
+    thead th.is-holiday-off:not(.is-today) {
       background: rgba(245, 108, 108, 0.08);
     }
+    thead th.is-holiday-work:not(.is-today) {
+      background: var(--el-fill-color-lighter);
+    }
+    thead th.is-weekend:not(.is-today) {
+      background: rgba(230, 162, 60, 0.08);
+    }
     .holiday-tag {
       &.is-off {
         background: rgba(245, 108, 108, 0.16);
@@ -862,6 +1188,11 @@ html.dark & {
         color: var(--el-text-color-secondary);
         border-color: var(--el-border-color-lighter);
       }
+      &.is-off-weekend {
+        background: rgba(230, 162, 60, 0.18);
+        color: #ebb563;
+        border-color: rgba(230, 162, 60, 0.35);
+      }
     }
     .holiday-name {
       color: #f89898;
@@ -883,7 +1214,16 @@ html.dark & {
     }
     .shift-cell {
       &.is-today {
-        background: var(--el-color-primary-light-9);
+        background: rgba(103, 194, 58, 0.16);
+      }
+      &.is-holiday-off:not(.is-today) {
+        background: rgba(245, 108, 108, 0.06);
+      }
+      &.is-holiday-work:not(.is-today) {
+        background: var(--el-fill-color-lighter);
+      }
+      &.is-weekend:not(.is-today) {
+        background: rgba(230, 162, 60, 0.08);
       }
       &:hover {
         background: var(--el-fill-color-light);
diff --git a/backend/src/views/tools/passwordStore/index.vue b/backend/src/views/tools/passwordStore/index.vue
index 88fef2f..4e98958 100644
--- a/backend/src/views/tools/passwordStore/index.vue
+++ b/backend/src/views/tools/passwordStore/index.vue
@@ -132,7 +132,7 @@
           </template>
         </el-table-column>
 
-        <el-table-column prop="platform" label="平台名称" min-width="160">
+        <el-table-column prop="platform" label="平台名称" min-width="200">
           <template #default="{ row }">
             <div class="platform-name-cell">
               <el-icon class="platform-icon"><Key /></el-icon>
diff --git a/cloc.exe b/cloc.exe
new file mode 100644
index 0000000..1a1c693
Binary files /dev/null and b/cloc.exe differ
diff --git a/go/controllers/backend_oa_scheduling.go b/go/controllers/backend_oa_scheduling.go
index 3d933e2..99839c5 100644
--- a/go/controllers/backend_oa_scheduling.go
+++ b/go/controllers/backend_oa_scheduling.go
@@ -231,6 +231,60 @@ func scDateSpan(start, end string) ([]string, string) {
 	return dates, ""
 }
 
+// scPlanNoEndDate 无期限方案的结束日期哨兵：数据库日期列不支持空串，
+// 统一存 2099-12-31，前端按 no_end 标记展示为「无期限」。
+const scPlanNoEndDate = "2099-12-31"
+
+// scDateSpanUnbounded 展开任意长度的日期区间，供无期限方案的
+// 「当年窗口」使用，不受 scDateSpan 的 92 天上限约束。
+func scDateSpanUnbounded(start, end string) ([]string, string) {
+	startDate, ok := scParseDate(start)
+	if !ok {
+		return nil, "开始日期格式错误"
+	}
+	endDate, ok := scParseDate(end)
+	if !ok {
+		return nil, "结束日期格式错误"
+	}
+	if endDate.Before(startDate) {
+		return nil, "结束日期不能早于开始日期"
+	}
+	total := int(endDate.Sub(startDate).Hours()/24) + 1
+	dates := make([]string, 0, total)
+	for cursor := startDate; !cursor.After(endDate); cursor = cursor.AddDate(0, 0, 1) {
+		dates = append(dates, cursor.Format("2006-01-02"))
+	}
+	return dates, ""
+}
+
+// scIsNoEnd 判断结束日期是否表示无期限（空串或哨兵值）。
+func scIsNoEnd(end string) bool {
+	return end == "" || end >= scPlanNoEndDate
+}
+
+// scPlanGenWindow 计算一次预览 / 发布实际展开的日期窗口。
+// 普通方案：[start, end] 原样展开；无期限方案：从 max(start, 今天) 生成到
+// 当年 12 月 31 日，跨年不自动延续，新的一年需要重新排班。
+func scPlanGenWindow(startText, endText string) ([]string, string) {
+	if !scIsNoEnd(endText) {
+		return scDateSpan(startText, endText)
+	}
+	startDate, ok := scParseDate(startText)
+	if !ok {
+		return nil, "开始日期格式错误"
+	}
+	windowStart := startDate
+	today := time.Now()
+	if today.After(startDate) {
+		windowStart = today
+	}
+	windowEnd := time.Date(today.Year(), 12, 31, 0, 0, 0, 0, today.Location())
+	if windowEnd.Before(windowStart) {
+		windowEnd = windowStart
+	}
+	return scDateSpanUnbounded(windowStart.Format("2006-01-02"), windowEnd.Format("2006-01-02"))
+}
+
 // scMinutes 把 "HH:mm" 转为当日分钟数。
 func scMinutes(value string) (int, bool) {
 	if value == "" {
diff --git a/go/controllers/backend_oa_scheduling_board.go b/go/controllers/backend_oa_scheduling_board.go
index 1e406ca..a7585ed 100644
--- a/go/controllers/backend_oa_scheduling_board.go
+++ b/go/controllers/backend_oa_scheduling_board.go
@@ -400,7 +400,11 @@ func (c *BackendOaSchedulingController) SaveEntries() {
 				row.Note = note
 				row.CreatedBy = uid
 				row.CreatedByName = username
-				if _, updateErr := models.Orm.Update(row); updateErr != nil {
+				// 指定字段更新：DATE 列从库里读回 string 会带上
+				// "00:00:00 +0800 CST" 后缀，全字段 Update 会写回导致 MySQL 1292
+				if _, updateErr := models.Orm.Update(row,
+					"shift_id", "shift_name", "short_name", "color", "work_start", "work_end",
+					"source", "note", "created_by", "created_by_name"); updateErr != nil {
 					c.scFail(500, 500, "调整排班失败: "+updateErr.Error())
 					return
 				}
@@ -445,6 +449,205 @@ func (c *BackendOaSchedulingController) SaveEntries() {
 	c.scOK(stats)
 }
 
+// SaveEntryCells 批量按格子编辑排班：cells 为任意「员工 × 日期」组合（排班板多选）。
+// shift_id>0 时把这些格子设为该班次（已有排班视为调班，无排班则新增临时排班）；
+// shift_id=0 时清除这些格子的排班（休息 / 请假）。
+// POST /backend/oa/scheduling/entries/save-cells
+func (c *BackendOaSchedulingController) SaveEntryCells() {
+	tid, uid, username, ok := c.scOperator()
+	if !ok {
+		return
+	}
+	body := c.scBody()
+
+	type scCellTarget struct {
+		employeeID uint
+		date       string
+	}
+	rawCells, _ := body["cells"].([]interface{})
+	seen := map[string]bool{}
+	cells := make([]scCellTarget, 0, len(rawCells))
+	for _, raw := range rawCells {
+		item, ok := raw.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		employeeID := uint(scUintValue(item, "employee_id"))
+		date := normalizeOaDate(scStringValue(item, "schedule_date", "date"))
+		if employeeID == 0 || date == "" {
+			continue
+		}
+		if _, err := time.Parse("2006-01-02", date); err != nil {
+			c.scFail(400, 400, "存在无效的日期: "+date)
+			return
+		}
+		key := fmt.Sprintf("%d|%s", employeeID, date)
+		if seen[key] {
+			continue
+		}
+		seen[key] = true
+		cells = append(cells, scCellTarget{employeeID: employeeID, date: date})
+	}
+	if len(cells) == 0 {
+		c.scFail(400, 400, "请先选择要编辑的格子")
+		return
+	}
+	if len(cells) > scPlanMaxEntries {
+		c.scFail(400, 400, fmt.Sprintf("单次最多编辑 %d 个格子", scPlanMaxEntries))
+		return
+	}
+
+	shiftID := scUintValue(body, "shift_id")
+	var shift *models.OaShift
+	if shiftID > 0 {
+		loaded, found := c.scLoadShift(tid, shiftID)
+		if !found {
+			c.scFail(400, 400, "班次不存在或已停用")
+			return
+		}
+		shift = loaded
+	}
+
+	// 排班来源：normal=正常排班（不显示临时标记），temp=临时调整（默认，显示「临」角标）
+	entrySource := models.OaEntrySourceTemp
+	if scStringValue(body, "source") == "normal" {
+		entrySource = models.OaEntrySourcePlan
+	}
+
+	empIDSet := map[uint]bool{}
+	empIDs := make([]uint64, 0, len(cells))
+	dates := make([]string, 0, len(cells))
+	for _, cell := range cells {
+		if !empIDSet[cell.employeeID] {
+			empIDSet[cell.employeeID] = true
+			empIDs = append(empIDs, uint64(cell.employeeID))
+		}
+		dates = append(dates, cell.date)
+	}
+	var employees []models.BackendEmployee
+	if _, err := c.scBaseEmployeeQuery(tid).Filter("id__in", empIDs).All(&employees); err != nil && err != orm.ErrNoRows {
+		c.scFail(500, 500, "查询员工失败: "+err.Error())
+		return
+	}
+	employeeMap := map[uint]*models.BackendEmployee{}
+	for i := range employees {
+		employeeMap[employees[i].ID] = &employees[i]
+	}
+
+	var existing []models.OaScheduleEntry
+	if _, err := c.scEntryQuery(tid).
+		Filter("employee_id__in", empIDs).
+		Filter("schedule_date__in", dates).
+		All(&existing); err != nil && err != orm.ErrNoRows {
+		c.scFail(500, 500, "查询已有排班失败: "+err.Error())
+		return
+	}
+	existingMap := map[string]*models.OaScheduleEntry{}
+	for i := range existing {
+		key := fmt.Sprintf("%d|%s", existing[i].EmployeeID, normalizeOaDate(existing[i].ScheduleDate))
+		existingMap[key] = &existing[i]
+	}
+
+	index := c.scLoadOrgIndex(tid)
+	note := scStringValue(body, "note")
+	stats := map[string]int{"created": 0, "updated": 0, "cleared": 0, "skipped": 0}
+	now := time.Now()
+
+	for _, cell := range cells {
+		employee, found := employeeMap[cell.employeeID]
+		if !found {
+			stats["skipped"]++
+			continue
+		}
+		key := fmt.Sprintf("%d|%s", cell.employeeID, cell.date)
+		row := existingMap[key]
+		orgID := scEmployeeDepartmentID(*employee)
+		position := ""
+		if employee.Position != nil {
+			position = *employee.Position
+		}
+
+		// 清除排班（休息 / 请假）：只处理已有排班的格子
+		if shift == nil {
+			if row == nil {
+				stats["skipped"]++
+				continue
+			}
+			oldShiftID, oldShiftName := row.ShiftID, row.ShiftName
+			row.IsDeleted = row.ID
+			row.DeleteTime = &now
+			if _, updateErr := models.Orm.Update(row, "is_deleted", "delete_time"); updateErr != nil {
+				c.scFail(500, 500, "清除排班失败: "+updateErr.Error())
+				return
+			}
+			c.scWriteChange(models.Orm, tid, row.ID, row.EmployeeID, row.EmployeeName, cell.date,
+				models.OaChangeClear, oldShiftID, oldShiftName, 0, "", note, uid, username)
+			stats["cleared"]++
+			continue
+		}
+
+		// 已有排班：调整为目标班次（调班）
+		if row != nil {
+			oldShiftID, oldShiftName := row.ShiftID, row.ShiftName
+			row.ShiftID = shift.ID
+			row.ShiftName = shift.Name
+			row.ShortName = shift.ShortName
+			row.Color = shift.Color
+			row.WorkStart = shift.WorkStart
+			row.WorkEnd = shift.WorkEnd
+			row.Source = entrySource
+			row.Note = note
+			row.CreatedBy = uid
+			row.CreatedByName = username
+			// 指定字段更新：DATE 列从库里读回 string 会带上
+			// "00:00:00 +0800 CST" 后缀，全字段 Update 会写回导致 MySQL 1292
+			if _, updateErr := models.Orm.Update(row,
+				"shift_id", "shift_name", "short_name", "color", "work_start", "work_end",
+				"source", "note", "created_by", "created_by_name"); updateErr != nil {
+				c.scFail(500, 500, "调整排班失败: "+updateErr.Error())
+				return
+			}
+			c.scWriteChange(models.Orm, tid, row.ID, row.EmployeeID, row.EmployeeName, cell.date,
+				models.OaChangeShift, oldShiftID, oldShiftName, shift.ID, shift.Name, note, uid, username)
+			stats["updated"]++
+			continue
+		}
+
+		// 无排班：新增临时排班（上班）
+		entry := &models.OaScheduleEntry{
+			Tid:             int(tid),
+			EmployeeID:      employee.ID,
+			EmployeeName:    employee.Name,
+			EmployeeAccount: employee.Account,
+			OrgID:           orgID,
+			OrgName:         index.name(orgID),
+			Position:        position,
+			ScheduleDate:    cell.date,
+			ShiftID:         shift.ID,
+			ShiftName:       shift.Name,
+			ShortName:       shift.ShortName,
+			Color:           shift.Color,
+			WorkStart:       shift.WorkStart,
+			WorkEnd:         shift.WorkEnd,
+			Source:          entrySource,
+			Note:            note,
+			CreatedBy:       uid,
+			CreatedByName:   username,
+		}
+		if _, insertErr := models.Orm.Insert(entry); insertErr != nil {
+			c.scFail(500, 500, "新增排班失败: "+insertErr.Error())
+			return
+		}
+		existingMap[key] = entry
+		c.scWriteChange(models.Orm, tid, entry.ID, entry.EmployeeID, entry.EmployeeName, cell.date,
+			models.OaChangeManual, 0, "", shift.ID, shift.Name, note, uid, username)
+		stats["created"]++
+	}
+
+	stats["cell_count"] = len(cells)
+	c.scOK(stats)
+}
+
 // SwapEntry 单条调班：把某个员工某天的班次换成另一个班次。
 // POST /backend/oa/scheduling/entries/swap/:id
 func (c *BackendOaSchedulingController) SwapEntry() {
diff --git a/go/controllers/backend_oa_scheduling_pattern.go b/go/controllers/backend_oa_scheduling_pattern.go
index 7ed04e4..348d96b 100644
--- a/go/controllers/backend_oa_scheduling_pattern.go
+++ b/go/controllers/backend_oa_scheduling_pattern.go
@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"server/models"
+	"server/pkg/holiday"
 )
 
 // scPatternDay 排班方案周期规则的每日快照。
@@ -212,6 +213,12 @@ func scPlanWorkRules(plan *models.OaSchedulePlan, fallback *models.OaShift, date
 		}
 	}
 
+	// 周期类方案：构造基准周期之外的顺延上下文（节假日 / 调休修正 + 星期节奏）
+	var rollExt *scRollExt
+	if plan.AlignMode == models.SchedTplAlignRoll || plan.AlignMode == models.SchedTplAlignWeek {
+		rollExt = scBuildRollExt(pattern, start, dates)
+	}
+
 	result := make(map[string]scPatternDay, len(dates))
 	workdays := make([]string, 0, len(dates))
 	for _, date := range dates {
@@ -219,7 +226,7 @@ func scPlanWorkRules(plan *models.OaSchedulePlan, fallback *models.OaShift, date
 		if !valid {
 			continue
 		}
-		rule, work := scRuleForDate(plan, rules, fallback, start, day, weekdays)
+		rule, work := scRuleForDate(plan, rules, fallback, start, day, weekdays, rollExt)
 		if !work {
 			continue
 		}
@@ -229,9 +236,109 @@ func scPlanWorkRules(plan *models.OaSchedulePlan, fallback *models.OaShift, date
 	return result, workdays, ""
 }
 
+// scRollExt 周期滚动方案（AlignMode=2，按月涂排）在基准周期之外的顺延上下文。
+//
+// 涂刷基准月里的节假日安排属于「基准月的特殊规则」，不应该跟着日序号平移到
+// 后续月份——否则 10 月的国庆假期会错位落到 11 月的普通工作日上。周期之外的
+// 推算规则：
+//  1. 目标日期是法定节假日 → 休息；
+//  2. 目标日期是调休上班日 → 上班（取涂刷里的班次）；
+//  3. 该星期在涂刷周期内呈现严格 休/班 交替（如大小周的周六）→ 按周序奇偶交替顺延；
+//  4. 其余按涂刷月的星期节奏顺延（同星期几在周期内的多数状态）。
+type scRollExt struct {
+	weekdayRules [8]scPatternDay // 下标 1-7（周一~周日）：该星期的顺延规则
+	altRules     [8]bool         // 该星期是否隔周交替（严格 休/班 交替）
+	altEven      [8]scPatternDay // 交替星期：周序为偶数时的规则
+	altOdd       [8]scPatternDay // 交替星期：周序为奇数时的规则
+	defaultWork  scPatternDay    // 涂刷里的首个上班规则，供调休上班日使用
+	holidays     map[string]int8 // 目标日期 → holiday.Type（0 调休上班 / 1 法定放假）
+}
+
+// scBuildRollExt 从涂刷周期构造顺延上下文。星期节奏取多数状态（work 数 - rest 数
+// ≥ 0 视为上班，班次取该星期首个上班规则）；若某星期在周期内严格 休/班 交替，
+// 记录交替规则，顺延按周序奇偶保持交替（周序锚点 = start 所在周的周一）。
+// 节假日数据按目标区间涉及的年份拉取，拉取失败只是少了节假日修正，不阻断发布。
+func scBuildRollExt(pattern []scPatternDay, start time.Time, dates []string) *scRollExt {
+	ext := &scRollExt{holidays: map[string]int8{}}
+	workCount := [8]int{}
+	shiftBy := [8]scPatternDay{}
+	type weekSeqItem struct {
+		week int
+		work bool
+		item scPatternDay
+	}
+	byWeekday := [8][]weekSeqItem{}
+	startMonday := start.AddDate(0, 0, -scWeekdayOffset(start))
+	for _, item := range pattern {
+		day := start.AddDate(0, 0, item.DayIndex)
+		w := scWeekdayOffset(day) + 1
+		if item.DayType == models.SchedTplDayWork {
+			workCount[w]++
+			if shiftBy[w].ShiftID == 0 {
+				shiftBy[w] = item
+			}
+			if ext.defaultWork.ShiftID == 0 {
+				ext.defaultWork = item
+			}
+		} else {
+			workCount[w]--
+		}
+		weekSeq := int(day.AddDate(0, 0, -scWeekdayOffset(day)).Sub(startMonday).Hours()/24) / 7
+		byWeekday[w] = append(byWeekday[w], weekSeqItem{week: weekSeq, work: item.DayType == models.SchedTplDayWork, item: item})
+	}
+	for w := 1; w <= 7; w++ {
+		if workCount[w] >= 0 && shiftBy[w].ShiftID != 0 {
+			ext.weekdayRules[w] = shiftBy[w]
+		} else {
+			ext.weekdayRules[w] = scPatternDay{DayIndex: w - 1, DayType: models.SchedTplDayRest}
+		}
+		// 隔周交替检测：该星期在涂刷周期内严格 休/班 交替（如大小周的周六，
+		// 一周上班一周休息），顺延时按周序奇偶保持交替，而不是取多数
+		list := byWeekday[w]
+		if len(list) < 2 {
+			continue
+		}
+		alternating := true
+		for i := 1; i < len(list); i++ {
+			if list[i].work == list[i-1].work {
+				alternating = false
+				break
+			}
+		}
+		if !alternating {
+			continue
+		}
+		ext.altRules[w] = true
+		if list[0].week%2 == 0 {
+			ext.altEven[w] = list[0].item
+			ext.altOdd[w] = list[1].item
+		} else {
+			ext.altOdd[w] = list[0].item
+			ext.altEven[w] = list[1].item
+		}
+	}
+	years := map[int]bool{}
+	for _, date := range dates {
+		if y := holidayYear(date); y > 0 {
+			years[y] = true
+		}
+	}
+	for y := range years {
+		items, _, err := holiday.FetchYear(y)
+		if err != nil {
+			continue
+		}
+		for _, d := range items {
+			ext.holidays[d.Date] = d.Type
+		}
+	}
+	return ext
+}
+
 // scRuleForDate 推算某一天命中的规则；第二个返回值表示当天是否上班。
+// ext 是周期滚动方案（AlignMode=2）在基准周期之外的顺延上下文，可为 nil。
 func scRuleForDate(plan *models.OaSchedulePlan, rules map[int]scPatternDay, fallback *models.OaShift,
-	start, day time.Time, weekdays map[int]bool) (scPatternDay, bool) {
+	start, day time.Time, weekdays map[int]bool, ext *scRollExt) (scPatternDay, bool) {
 	switch plan.AlignMode {
 	case models.SchedTplAlignWeek:
 		weeks := plan.CycleDays / 7
@@ -241,6 +348,18 @@ func scRuleForDate(plan *models.OaSchedulePlan, rules map[int]scPatternDay, fall
 		startMonday := start.AddDate(0, 0, -scWeekdayOffset(start))
 		curMonday := day.AddDate(0, 0, -scWeekdayOffset(day))
 		diffWeeks := int(curMonday.Sub(startMonday).Hours()/24) / 7
+		// 首个周期内原样回放；周期之外目标月的节假日 / 调休优先修正
+		//（大小周等模板按自然周循环，周序永远交替不串位）
+		if ext != nil && diffWeeks >= weeks {
+			if hType, ok := ext.holidays[day.Format("2006-01-02")]; ok {
+				if hType == holiday.TypeHoliday {
+					return scPatternDay{}, false
+				}
+				if hType == holiday.TypeWorkday && ext.defaultWork.ShiftID != 0 {
+					return ext.defaultWork, true
+				}
+			}
+		}
 		weekIndex := scMod(diffWeeks+int(plan.WeekOffset), weeks)
 		return scRuleOfDay(rules, weekIndex*7+scWeekdayOffset(day))
 
@@ -250,6 +369,41 @@ func scRuleForDate(plan *models.OaSchedulePlan, rules map[int]scPatternDay, fall
 			cycle = 1
 		}
 		diffDays := int(day.Sub(start).Hours() / 24)
+		// 基准周期内：按涂刷结果原样回放（涂刷月自己的节假日 / 周末已在保存时处理）
+		if diffDays < cycle || ext == nil {
+			return scRuleOfDay(rules, scMod(diffDays, cycle))
+		}
+		// 周期之外：先看目标日的节假日 / 调休特殊规则
+		if hType, ok := ext.holidays[day.Format("2006-01-02")]; ok {
+			if hType == holiday.TypeHoliday {
+				return scPatternDay{}, false
+			}
+			if hType == holiday.TypeWorkday && ext.defaultWork.ShiftID != 0 {
+				return ext.defaultWork, true
+			}
+		}
+		// 整月涂刷方案（周期=开始月天数）：按星期节奏顺延，规避节假日 / 周末错位；
+		// 其他滚动周期（三班倒 / 做一休一等模板原生周期）：保持相位纯滚动
+		daysInStartMonth := time.Date(start.Year(), start.Month()+1, 0, 0, 0, 0, 0, start.Location()).Day()
+		if cycle == daysInStartMonth {
+			w := scWeekdayOffset(day) + 1
+			rule := ext.weekdayRules[w]
+			// 隔周交替的星期（如大小周的周六）：按周序奇偶保持交替
+			if ext.altRules[w] {
+				startMonday := start.AddDate(0, 0, -scWeekdayOffset(start))
+				curMonday := day.AddDate(0, 0, -scWeekdayOffset(day))
+				weekSeq := int(curMonday.Sub(startMonday).Hours()/24) / 7
+				if weekSeq%2 == 0 {
+					rule = ext.altEven[w]
+				} else {
+					rule = ext.altOdd[w]
+				}
+			}
+			if rule.DayType != models.SchedTplDayWork {
+				return scPatternDay{}, false
+			}
+			return rule, true
+		}
 		return scRuleOfDay(rules, scMod(diffDays, cycle))
 
 	case models.SchedTplAlignMonth:
diff --git a/go/controllers/backend_oa_scheduling_plan.go b/go/controllers/backend_oa_scheduling_plan.go
index 505fb91..79f832b 100644
--- a/go/controllers/backend_oa_scheduling_plan.go
+++ b/go/controllers/backend_oa_scheduling_plan.go
@@ -98,7 +98,13 @@ func (c *BackendOaSchedulingController) scPlanInputFromBody(body map[string]inte
 		input.IncludeChild = scBoolValue(body, "include_child")
 	}
 
-	if _, msg := scDateSpan(input.StartDate, input.EndDate); msg != "" {
+	// 无期限方案：结束日期允许为空，落库时存哨兵值，发布时按滚动窗口分批生成
+	if scIsNoEnd(input.EndDate) {
+		if _, ok := scParseDate(input.StartDate); !ok {
+			return nil, "开始日期格式错误"
+		}
+		input.EndDate = scPlanNoEndDate
+	} else if _, msg := scDateSpan(input.StartDate, input.EndDate); msg != "" {
 		return nil, msg
 	}
 
@@ -181,6 +187,7 @@ func scPlanView(plan *models.OaSchedulePlan) map[string]interface{} {
 		"employee_names":     plan.EmployeeNames,
 		"start_date":         normalizeOaDate(plan.StartDate),
 		"end_date":           normalizeOaDate(plan.EndDate),
+		"no_end":             scIsNoEnd(plan.EndDate),
 		"weekdays":           weekdays,
 		"shift_id":           plan.ShiftID,
 		"shift_name":         plan.ShiftName,
@@ -330,7 +337,7 @@ func (c *BackendOaSchedulingController) PlanPreview() {
 		return
 	}
 
-	dates, msg := scDateSpan(input.StartDate, input.EndDate)
+	dates, msg := scPlanGenWindow(input.StartDate, input.EndDate)
 	if msg != "" {
 		c.scFail(400, 400, msg)
 		return
@@ -369,6 +376,9 @@ func (c *BackendOaSchedulingController) PlanPreview() {
 		"workday_count":  len(workdays),
 		"rest_count":     len(dates) - len(workdays),
 		"entry_count":    entryCount,
+		"no_end":         scIsNoEnd(input.EndDate),
+		"gen_start":      dates[0],
+		"gen_end":        dates[len(dates)-1],
 		"shift":          shift,
 		"scope_name":     c.scScopeName(tid, input),
 		"template_name":  input.TemplateName,
@@ -673,7 +683,7 @@ func (c *BackendOaSchedulingController) scPublishPlan(tid, uid uint64, username
 		return nil, fmt.Errorf("范围覆盖 %d 名员工，超过单次 %d 人上限", len(employees), scPlanMaxEmployees)
 	}
 
-	dates, msg := scDateSpan(normalizeOaDate(plan.StartDate), normalizeOaDate(plan.EndDate))
+	dates, msg := scPlanGenWindow(normalizeOaDate(plan.StartDate), normalizeOaDate(plan.EndDate))
 	if msg != "" {
 		return nil, errors.New(msg)
 	}
diff --git a/go/controllers/backend_oa_scheduling_template.go b/go/controllers/backend_oa_scheduling_template.go
index 440d698..6665a7c 100644
--- a/go/controllers/backend_oa_scheduling_template.go
+++ b/go/controllers/backend_oa_scheduling_template.go
@@ -121,71 +121,63 @@ func (c *BackendOaSchedulingController) TemplateApply() {
 		c.scFail(500, 500, "查询班次失败: "+err.Error())
 		return
 	}
+	// 班次匹配索引：精确（名称+时间）→ 名称 → 兜底（默认班次 / 第一个可用班次）。
+	// 不强制时间一致，也不自动创建班次，由用户在方案里自行判断调整
 	shiftMap := make(map[string]*models.OaShift, len(shifts))
-	maxSort := 0
+	shiftNameMap := make(map[string]*models.OaShift, len(shifts))
+	var fallbackShift *models.OaShift
 	for i := range shifts {
 		shift := &shifts[i]
 		shiftMap[schedShiftKey(shift.Name, shift.WorkStart, shift.WorkEnd)] = shift
-		if shift.Sort > maxSort {
-			maxSort = shift.Sort
+		if _, ok := shiftNameMap[shift.Name]; !ok {
+			shiftNameMap[shift.Name] = shift
+		}
+		if fallbackShift == nil || (shift.IsDefault == 1 && fallbackShift.IsDefault != 1) {
+			fallbackShift = shift
 		}
 	}
 
 	patterns := []scPatternDay{}
-	createdShifts := 0
 	matchedShifts := 0
 	for _, day := range c.schedTplDays(tpl.ID) {
 		if day.DayType != models.SchedTplDayWork {
 			patterns = append(patterns, scPatternDay{DayIndex: day.DayIndex, DayType: models.SchedTplDayRest})
 			continue
 		}
-		key := schedShiftKey(day.ShiftName, day.WorkStart, day.WorkEnd)
-		shift, hit := shiftMap[key]
-		if hit {
-			matchedShifts++
-		} else {
-			maxSort += 10
-			shift = &models.OaShift{
-				Tid:       int(tid),
-				Name:      day.ShiftName,
-				ShortName: day.ShiftShort,
-				Color:     day.Color,
-				WorkStart: day.WorkStart,
-				WorkEnd:   day.WorkEnd,
-				RestStart: day.RestStart,
-				RestEnd:   day.RestEnd,
-				WorkHours: day.WorkHours,
-				IsDefault: 0,
-				Status:    1,
-				Sort:      maxSort,
-				IsDeleted: 0,
-			}
-			if shift.ShortName == "" {
-				shift.ShortName = shift.Name
-			}
-			if shift.Color == "" {
-				shift.Color = "#409EFF"
-			}
-			if _, err := models.Orm.Insert(shift); err != nil {
-				c.scFail(500, 500, "创建班次失败: "+err.Error())
-				return
-			}
-			shiftMap[key] = shift
-			createdShifts++
+		shift := shiftMap[schedShiftKey(day.ShiftName, day.WorkStart, day.WorkEnd)]
+		if shift == nil {
+			shift = shiftNameMap[strings.TrimSpace(day.ShiftName)]
 		}
-		patterns = append(patterns, scPatternDay{
+		if shift == nil {
+			shift = fallbackShift
+		}
+		if shift != nil {
+			matchedShifts++
+		}
+		item := scPatternDay{
 			DayIndex:  day.DayIndex,
 			DayType:   models.SchedTplDayWork,
-			ShiftID:   shift.ID,
-			ShiftName: shift.Name,
-			ShortName: shift.ShortName,
-			Color:     shift.Color,
-			WorkStart: shift.WorkStart,
-			WorkEnd:   shift.WorkEnd,
-			RestStart: shift.RestStart,
-			RestEnd:   shift.RestEnd,
-			WorkHours: shift.WorkHours,
-		})
+			ShiftName: day.ShiftName,
+			ShortName: day.ShiftShort,
+			Color:     day.Color,
+			WorkStart: day.WorkStart,
+			WorkEnd:   day.WorkEnd,
+			RestStart: day.RestStart,
+			RestEnd:   day.RestEnd,
+			WorkHours: day.WorkHours,
+		}
+		if shift != nil {
+			item.ShiftID = shift.ID
+			item.ShiftName = shift.Name
+			item.ShortName = shift.ShortName
+			item.Color = shift.Color
+			item.WorkStart = shift.WorkStart
+			item.WorkEnd = shift.WorkEnd
+			item.RestStart = shift.RestStart
+			item.RestEnd = shift.RestEnd
+			item.WorkHours = shift.WorkHours
+		}
+		patterns = append(patterns, item)
 	}
 	if len(patterns) == 0 {
 		c.scFail(400, 400, "该模板没有配置排班规则")
@@ -196,7 +188,6 @@ func (c *BackendOaSchedulingController) TemplateApply() {
 		"template":      schedTplView(tpl, nil),
 		"pattern":       patterns,
 		"days":          patterns,
-		"created_shift": createdShifts,
 		"matched_shift": matchedShifts,
 	})
 }
diff --git a/go/routers/backend/backend.go b/go/routers/backend/backend.go
index c991068..d5e5ae9 100644
--- a/go/routers/backend/backend.go
+++ b/go/routers/backend/backend.go
@@ -357,6 +357,7 @@ func RegisterAuthRoutes() {
 	beego.Router("/backend/oa/scheduling/plans/publish/:id", &controllers.BackendOaSchedulingController{}, "post:PlanPublish")
 	beego.Router("/backend/oa/scheduling/plans/delete/:id", &controllers.BackendOaSchedulingController{}, "delete:PlanDelete")
 	beego.Router("/backend/oa/scheduling/entries/save", &controllers.BackendOaSchedulingController{}, "post:SaveEntries")
+	beego.Router("/backend/oa/scheduling/entries/save-cells", &controllers.BackendOaSchedulingController{}, "post:SaveEntryCells")
 	beego.Router("/backend/oa/scheduling/entries/swap/:id", &controllers.BackendOaSchedulingController{}, "post:SwapEntry")
 	beego.Router("/backend/oa/scheduling/entries/clear", &controllers.BackendOaSchedulingController{}, "post:ClearEntries")
 	beego.Router("/backend/oa/scheduling/changes", &controllers.BackendOaSchedulingController{}, "get:ChangeList")
diff --git a/platform/src/views/tools/passwordStore/index.vue b/platform/src/views/tools/passwordStore/index.vue
index 0fef209..fc8b837 100644
--- a/platform/src/views/tools/passwordStore/index.vue
+++ b/platform/src/views/tools/passwordStore/index.vue
@@ -132,7 +132,7 @@
           </template>
         </el-table-column>
 
-        <el-table-column prop="platform" label="平台名称" min-width="160">
+        <el-table-column prop="platform" label="平台名称" min-width="200">
           <template #default="{ row }">
             <div class="platform-name-cell">
               <el-icon class="platform-icon"><Key /></el-icon>
@@ -168,7 +168,7 @@
           </template>
         </el-table-column>
 
-        <el-table-column label="账号预览" min-width="220" show-overflow-tooltip>
+        <el-table-column label="账号预览" min-width="220">
           <template #default="{ row }">
             <div v-if="row.accounts && row.accounts.length > 0" class="account-preview-tags">
               <el-tag
@@ -177,6 +177,7 @@
                 size="small"
                 class="acc-preview-tag"
                 type="info"
+                :title="acc.username || '(无账号名)'"
               >
                 {{ acc.username || '(无账号名)' }}
               </el-tag>
@@ -924,10 +925,19 @@ onMounted(load)
 }
 
 .acc-preview-tag {
-  max-width: 110px;
+  max-width: 140px;
+  min-width: 0;
+  flex-shrink: 1;
+}
+
+/* el-tag 文字在内层 .el-tag__content 中，需用 :deep 才能让省略号生效 */
+.acc-preview-tag :deep(.el-tag__content) {
+  display: inline-block;
+  max-width: 100%;
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
+  vertical-align: bottom;
 }
 
 .more-tag {