Session Manager

Session Manager Skill

核心问题: 如何保证工作流在会话断开后仍然生效？ 解决方案: 强制状态持久化 + 强制恢复检查 + 模式锁定

🎯 核心目标

1. 会话断开不丢失状态 — 所有状态持久化到文件
2. 新会话自动恢复模式 — 不退化为普通对话
3. 工作流锁定 — 直到流程完成才能切换

📁 会话状态文件

project_document/.ai_state/
├── session.yaml          # 🆕 会话状态（核心）
├── active_context.md     # 当前任务和TODO
├── kanban.md             # 三态看板
├── workflow.lock         # 🆕 工作流锁
└── checkpoint.md         # 🆕 断点恢复信息

session.yaml 结构

# 会话状态 - 每次操作都要更新
session:
  id: "sess_20250112_001"
  created_at: "2025-01-12T10:00:00Z"
  updated_at: "2025-01-12T10:30:00Z"
  
# 当前模式 - 决定AI行为方式
mode:
  type: "workflow"           # workflow | conversation | paused
  workflow_name: "vibe-code" # 当前执行的工作流
  phase: "E"                 # R1 | I | P | E | R2
  step: "4.3"                # 当前步骤
  
# 工作流状态
workflow:
  started_at: "2025-01-12T10:00:00Z"
  current_task: "T-002"
  total_tasks: 5
  completed_tasks: 1
  status: "running"          # running | paused | completed | failed
  
# 上下文摘要 - 用于恢复
context:
  goal: "实现用户认证系统"
  last_action: "完成了数据模型设计"
  next_action: "实现API接口"
  pending_questions: []
  
# 断点信息 - 用于精确恢复
checkpoint:
  file: "src/api/auth.ts"
  line: 45
  action: "implementing login function"

workflow.lock 结构

# 工作流锁 - 防止模式切换
locked: true
workflow: "vibe-code"
reason: "工作流执行中，需完成后才能切换"
unlock_conditions:
  - "所有TODO完成"
  - "用户通过寸止确认"
  - "用户主动解锁 /vibe-unlock"

🔄 会话生命周期

┌─────────────────────────────────────────────────────────────┐
│                    会话生命周期                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  新会话开始                                                  │
│       ↓                                                     │
│  ┌─────────────────────────────────────────────────────┐   │
│  │ Step 1: 强制检查 session.yaml                       │   │
│  │         是否存在？状态是什么？                        │   │
│  └─────────────────────────────────────────────────────┘   │
│       ↓                                                     │
│  ┌─────────────────────────────────────────────────────┐   │
│  │ Step 2: 检查 workflow.lock                          │   │
│  │         是否有未完成的工作流？                        │   │
│  └─────────────────────────────────────────────────────┘   │
│       ↓                                                     │
│  ┌─────────────────────────────────────┐                   │
│  │ 有锁？                               │                   │
│  └─────────────────────────────────────┘                   │
│       │                                                     │
│    Yes│                    No                               │
│       ↓                    ↓                                │
│  ┌─────────────┐    ┌─────────────┐                        │
│  │ 恢复模式    │    │ 普通模式    │                        │
│  │ 继续工作流  │    │ 等待指令    │                        │
│  └─────────────┘    └─────────────┘                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

🚀 强制启动序列

每次会话开始必须执行（无例外）：

async function onSessionStart() {
  // ========== 第一步：检查状态文件 ==========
  const sessionFile = 'project_document/.ai_state/session.yaml';
  const lockFile = 'project_document/.ai_state/workflow.lock';
  
  const sessionExists = await fileExists(sessionFile);
  const lockExists = await fileExists(lockFile);
  
  // ========== 第二步：根据状态决定行为 ==========
  if (lockExists) {
    const lock = await readYaml(lockFile);
    if (lock.locked) {
      // 🔒 有锁：强制恢复工作流模式
      await resumeWorkflow(lock.workflow);
      return;
    }
  }
  
  if (sessionExists) {
    const session = await readYaml(sessionFile);
    if (session.mode.type === 'workflow') {
      // 📋 有未完成工作流：恢复
      await resumeWorkflow(session.mode.workflow_name);
      return;
    }
    if (session.mode.type === 'paused') {
      // ⏸️ 暂停状态：提示用户
      await notifyPausedState(session);
      return;
    }
  }
  
  // ========== 第三步：无状态，等待指令 ==========
  await waitForCommand();
}

📢 恢复时的汇报格式

必须用这种格式汇报，不是普通对话：

## 🔄 会话恢复

### 当前状态
- **工作流**: vibe-code
- **阶段**: Execute (E)
- **进度**: 2/5 任务完成 (40%)

### 上次进展
- ✅ T-001: 数据模型设计
- ✅ T-002: 用户接口定义
- 🔄 T-003: 实现登录API (进行中)

### 下一步
继续执行 T-003: 实现登录API

### 断点位置
- 文件: `src/api/auth.ts`
- 进度: 登录函数框架已完成，待实现验证逻辑

---

**是否继续？** 回复 `继续` 或 `查看详情` 或 `暂停`

🔐 模式锁定机制

进入工作流时锁定

async function enterWorkflow(workflowName) {
  // 创建锁
  await writeYaml('project_document/.ai_state/workflow.lock', {
    locked: true,
    workflow: workflowName,
    locked_at: new Date().toISOString(),
    reason: '工作流执行中',
    unlock_conditions: [
      '所有TODO完成并通过寸止确认',
      '用户主动执行 /vibe-unlock',
      '用户执行 /vibe-pause'
    ]
  });
  
  // 更新会话状态
  await updateSession({
    mode: {
      type: 'workflow',
      workflow_name: workflowName,
      phase: 'R1',
      step: '1.1'
    }
  });
}

解锁条件

async function checkUnlock() {
  const canUnlock = 
    allTodosCompleted() &&
    userConfirmedViaCunzhi() &&
    noBlockingIssues();
    
  if (canUnlock) {
    await releaseLock();
  }
}

⏸️ 暂停和恢复

暂停指令: /vibe-pause

async function pause() {
  // 保存断点
  await writeFile('project_document/.ai_state/checkpoint.md', `
# 断点信息

## 暂停时间
${new Date().toISOString()}

## 当前位置
- 工作流: ${currentWorkflow}
- 阶段: ${currentPhase}
- 任务: ${currentTask}
- 文件: ${currentFile}

## 待继续工作
${pendingWork}

## 恢复指令
使用 /vibe-resume 继续
  `);
  
  // 更新状态
  await updateSession({ mode: { type: 'paused' } });
  await updateLock({ locked: false, paused: true });
}

恢复指令: /vibe-resume

async function resume() {
  const checkpoint = await readFile('checkpoint.md');
  const session = await readYaml('session.yaml');
  
  // 恢复到断点
  await restoreCheckpoint(checkpoint);
  
  // 重新锁定
  await enterWorkflow(session.mode.workflow_name);
  
  // 汇报并继续
  await reportAndContinue();
}

📋 状态更新时机

⚠️ 强制规则

1. 每次会话开始必须检查状态 — 无例外
2. 有锁必须恢复工作流 — 不能忽略
3. 不能在工作流中切换到对话模式 — 除非解锁
4. 状态文件是唯一真理 — 不依赖会话记忆

🔗 与其他技能协作

核心价值: 保证工作流跨会话持久 | 触发: 每次会话开始 | 优先级: 最高