# workflow-controller > 工作流控制器 - 接管所有skill和用户的交互，判定是否进入下一步，位于用户和re-check之间，自动加载项目IFLOW.md记忆并传递给质量控制层 - Author: hrply - Repository: hrply/iflow-skills - Version: 20260126131508 - Stars: 0 - Forks: 0 - Last Updated: 2026-02-06 - Source: https://github.com/hrply/iflow-skills - Web: https://mule.run/skillshub/@@hrply/iflow-skills~workflow-controller:20260126131508 --- --- name: workflow-controller description: 工作流控制器 - 接管所有skill和用户的交互，判定是否进入下一步，位于用户和re-check之间，自动加载项目IFLOW.md记忆并传递给质量控制层 license: MIT --- # Workflow Controller ## 概述 **交互层的核心控制器**，负责与用户的直接交互： 1. **接收所有用户输入** - 所有用户输入首先进入 workflow-controller 2. **强制确认机制** - 用户输入任何任务请求时，必须先展示"理解确认" 3. **计划确认机制** - 生成测试计划、代码前必须展示并等待确认 4. **自动加载项目记忆** - 读取项目目录下的 IFLOW.md 作为记忆 5. **执行过程自主** - 用户确认后保持自主执行 6. **反馈结果** - 接收质量控制层返回的最终结果并展示给用户 ## 核心原则 ### 强制确认规则 **以下操作必须先经过 workflow-controller 确认**： - `write_file`（写入文件） - `replace`（修改文件） - `run_shell_command`（执行命令） **以下操作可以自主执行**： - `read_file`（读取文件） - `glob`（文件搜索） - `search_file_content`（内容搜索） - `list_directory`（目录列表） --- ## 交互层强制确认（必需） ### 触发条件 用户输入任何任务请求时，必须先展示"理解确认"并等待用户确认。 ### 处理流程 ``` 用户输入任务请求 ↓ workflow-controller 接收输入 ↓ 展示"理解确认" ↓ 等待用户输入 "1" 或 "确认" 或 "否" ↓ 只有收到"1"或"确认"后才执行 ``` ### 标准确认语模板 ```markdown --- ## 理解确认 我的理解是： 1. [任务点1] 2. [任务点2] 3. [任务点3] **请确认：** - 输入 **1** 或 **确认** → 以上理解正确，继续执行 - 输入 **否** → 以上理解有误，请提供修改意见 --- ``` ### 多选项确认语模板 ```markdown --- ## 请选择 1. [选项1] 2. [选项2] 3. [选项3] **请输入选项编号（1-3）或直接输入您的意见：** ``` ### 强制接管关键词表 **触发条件**：以以下关键词开头的输入必须由 workflow-controller 接管 | 关键词 | 处理方式 | |-------|---------| | `提问：` | 进入理解确认流程 | | `意见：` | 进入理解确认流程 | | `修正：` | 进入理解确认流程 | **处理逻辑**： ``` 用户输入以关键词开头 ↓ workflow-controller 强制接管 ↓ 提取关键词后的内容作为任务请求 ↓ 进入理解确认流程 ``` ### 输入判断逻辑 ```python # 强制接管关键词表 MANDATORY_KEYWORDS = ['提问：', '意见：', '修正：'] def classify_user_input(user_input: str) -> dict: """ 判断用户输入类型： - 强制接管：以指定关键词开头的输入 - 确认类：对已有结果的回答或确认 - 选项选择：输入数字编号选择选项 - 修改意见：用户提出修改意见 - 新问题：用户提出新的任务需求 """ user_input = user_input.strip() # 1. 检查是否强制接管关键词（最高优先级） for keyword in MANDATORY_KEYWORDS: if user_input.startswith(keyword): content = user_input[len(keyword):].strip() return { 'type': 'forced_takeover', 'keyword': keyword, 'content': content, 'action': 'understanding_confirmation' } # 2. 检查是否确认类输入（简洁确认方式） if user_input == '1' or user_input.lower() == '确认': return { 'type': 'confirmation', 'action': 'proceed', 'content': user_input } # 3. 检查是否否认输入 if user_input.lower() == '否' or user_input.lower() == 'no' or user_input.lower() == 'n': return { 'type': 'revision', 'content': user_input, 'need_feedback': True # 需要用户进一步说明修改意见 } # 4. 检查是否数字选项选择（从2开始编号） if user_input.isdigit() and int(user_input) >= 2: return { 'type': 'option_selection', 'option_number': int(user_input), 'content': user_input } # 5. 检查是否修改意见（"否，"开头，兼容旧方式） if user_input.startswith('否，') or user_input.startswith('否,'): return { 'type': 'revision', 'content': user_input[2:].strip() } # 6. 兼容旧关键词（次要确认词） legacy_confirmation_keywords = ['确认', '是的', '对', '正确', '下一步'] if any(kw in user_input for kw in legacy_confirmation_keywords): return { 'type': 'confirmation', 'action': 'proceed', 'content': user_input } # 7. 默认为新问题 return { 'type': 'new_request', 'content': user_input } ``` ### 处理优先级 ``` 1. 强制接管关键词（最高优先级） - 提问：/意见：/修正：开头 → 提取内容 → 进入理解确认 2. 简洁确认（1 或 确认） → 执行下一步操作 3. 否认（否 / no / n） → 进入修订流程（需进一步说明） 4. 数字选项选择（2+） → 选择对应选项 5. 兼容旧关键词（次要） - "否，"开头 - 确认/是的/对/正确/下一步 → 视为确认或修订 6. 新问题（默认） → 进入理解确认流程 ``` ### 确认交互示例 **简洁确认**： ```markdown 我的理解是： 1. 设计一个UMAP聚类程序 2. 支持数据导入 3. 支持参数配置 请确认： - 输入 1 或 确认 → 以上理解正确，继续执行 - 输入 否 → 以上理解有误，请提供修改意见 ``` **多选项选择**： ```markdown 请选择： 1. Python 实现 2. R 实现 3. Web 应用 请输入选项编号（1-3）或直接输入您的意见： ``` **用户响应**： | 用户输入 | 处理结果 | |---------|---------| | `1` | 确认，进入下一步 | | `确认` | 确认，进入下一步 | | `否` | 否认，需进一步说明修改意见 | | `2` | 选择选项2 | | `3` | 选择选项3 | --- ## 计划确认机制（必需） ### 触发条件 生成测试计划、代码前必须展示并等待确认。 ### 处理流程 ``` 生成测试计划/代码 ↓ 展示计划内容 ↓ 等待用户确认 ↓ 确认后写入文件 ``` ### 计划确认语模板 ```markdown --- ## 计划确认 **测试计划内容**： [计划内容] **代码预览**： [代码内容] **请确认：** - 输入 **1** 或 **确认** → 以上计划满足要求，继续执行 - 输入 **否** → 以上计划有误，请提供修改意见 --- ``` --- ## 执行过程自主（保持） ### 触发条件 用户确认计划后，执行过程保持自主。 ### 处理流程 ``` 用户确认计划 ↓ 自主执行多轮测试 ↓ 每轮独立生成计划和代码 ↓ 自主执行容器内外测试 ↓ 完成所有轮次后汇总结果 ↓ 向用户汇报最终结果 ``` ### 自主执行原则 - 不需要每轮都与用户确认 - 每轮同时进行容器内和容器外测试 - 每次执行仍需生成新计划和代码 - 完成所有轮次后统一汇报 --- ## 自动加载项目记忆 ### IFLOW.md 自动加载 当进入项目目录时，workflow-controller 自动执行以下操作： ```python def load_project_memory(project_root: str) -> dict: """ 自动加载项目记忆 1. 读取项目根目录下的 IFLOW.md 2. 解析文档索引、全局原则、项目状态 3. 将其作为记忆的一部分传递给后续处理 """ iflow_path = os.path.join(project_root, 'IFLOW.md') if os.path.exists(iflow_path): iflow_content = read_file(iflow_path) return parse_iflow(iflow_content) return { 'docs_index': [], 'principles': { 'code': [], 'process': [], 'interaction': [] }, 'project_state': {} } ``` ### IFLOW.md 结构期望 ```markdown # iFlow 项目记忆 ## 文档索引 ... --- ## 全局原则（必读约束） ### 代码规范 - 所有代码修改必须在项目文件内进行 - 禁止直接运行应用，必须通过 docker-compose ### 验证流程 - 问题发现 → 撰写计划 → 生成内测代码 → 修复验证 ### 交互规范 - 所有对话必须经过 workflow-controller - 确认时使用"1"或"确认"，否认使用"否" - 理解确认后必须等待用户确认才能执行 --- ## 项目状态 ... ``` ### 传递给 re-checker ```python def send_to_quality_control(user_input: str, project_memory: dict) -> dict: """ 发送到质量控制层 自动将 IFLOW.md 的「全局原则」传递给 re-checker """ return { 'input': user_input, 'memory': { 'docs_index': project_memory.get('docs_index', []), 'principles': { 'code': project_memory['principles'].get('code', []), 'process': project_memory['principles'].get('process', []), 'interaction': project_memory['principles'].get('interaction', []) }, 'project_state': project_memory.get('project_state', {}) } } ``` --- ## 系统定位 ``` ┌─────────────────────────────────────────────────┐ │ 用户 │ └────────────────────┬────────────────────────────┘ ↓ 输入 ┌─────────────────────────────────────────────────┐ │ workflow-controller │ │ 1. 接收输入 │ │ 2. 强制确认（理解确认） │ │ 3. 加载 IFLOW.md 记忆 │ │ 4. 传递记忆给质量控制层 │ │ 5. 计划确认（生成计划/代码前） │ │ 6. 确认后自主执行 │ │ 7. 反馈结果 │ └────────────────────┬────────────────────────────┘ ↓ (input + memory) ┌─────────────────────────────────────────────────┐ │ re-checker + loop-management │ │ (质量控制层) │ │ - 验证回答符合记忆内的原则 │ └────────────────────┬────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────┐ │ internal-dispatcher (中枢) │ └────────────────────┬────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────┐ │ 任务处理层 (Skills) │ └─────────────────────────────────────────────────┘ ``` --- ## 完整工作流 ### 阶段一：理解确认（必需） ``` 用户输入: 我希望设计一个能够绘制UMAP聚类图象的程序 ↓ workflow-controller 接收输入 ↓ 展示"理解确认" ↓ 等待用户确认 ↓ 收到"1"或"确认"后继续 ``` ### 阶段二：质量控制 ``` re-checker + loop-management (质量控制 + 原则验证) ↓ logic-confirmation (确认理解) ↓ re-checker 重新确认（验证是否符合记忆内原则） ↓ loop-management 控制计数 ↓ 确认通过 → designer (输出设计思路) ↓ re-checker 重新确认（验证是否符合记忆内原则） ↓ loop-management 控制计数 ↓ 确认通过 → docs-builder (撰写详细文档) ↓ re-checker 重新确认（验证是否符合记忆内原则） ↓ loop-management 控制计数 ↓ 确认通过 → 写入 ./docs/ ``` ### 阶段三：计划确认（必需） ``` 生成测试计划 ↓ 展示计划内容 ↓ 等待用户确认 ↓ 确认后生成内测代码 ↓ 展示代码 ↓ 等待用户确认 ↓ 确认后执行 ``` ### 阶段四：执行过程自主 ``` 自主执行多轮测试 ↓ 每轮独立生成计划和代码 ↓ 自主执行容器内外测试 ↓ 完成所有轮次后汇总结果 ↓ 向用户汇报最终结果 ``` --- ## 确认状态管理 ```python class WorkflowState: """工作流状态""" def __init__(self): self.current_skill = None self.confirmation_stage = None # 'understanding' / 'design' / 'documentation' / 'plan' / 'execution' / 'final' self.confirmation_count = 0 self.modifications = [] self.last_user_input = None self.is_new_request = True # 新问题标记 self.project_memory = {} # IFLOW.md 记忆 self.needs_user_confirmation = True # 需要用户确认 WORKFLOW_STATES = {} ``` ### 状态定义 ```python WORKFLOW_STATE = { 'idle': { 'description': '等待用户输入', 'next_state': 'understanding_confirmation' }, 'understanding_confirmation': { 'description': '理解确认阶段', 'next_state': { 'confirm': 'quality_control', 'revise': 'revising' } }, 'quality_control': { 'description': '质量控制层处理', 'next_state': 'plan_confirmation' }, 'plan_confirmation': { 'description': '计划确认阶段', 'next_state': { 'confirm': 'execution', 'revise': 'revising_plan' } }, 'execution': { 'description': '自主执行阶段', 'next_state': 'final_report' }, 'final_report': { 'description': '最终汇报', 'next_state': 'idle' }, 'revising': { 'description': '修订处理', 'next_state': 'understanding_confirmation' }, 'revising_plan': { 'description': '修订计划', 'next_state': 'plan_confirmation' } } ``` ### 状态流转图 ``` ┌─────────┐ │ idle │ ←───────────────────────────────────┐ └────┬────┘ │ ↓ 输入 │ ┌────┴────┐ │ │understanding│ │ │confirmation │ │ └────┬────┘ │ ↓ │ ┌────┴────┐ │ │confirm │revise │ ↓ ↓ │ ┌────┐ ┌─────────────────┐ │ │ QC │ │ revising │ │ └────┘ └────────┬────────┘ │ ↓ ↓ │ ↓ understanding_confirmation │ ↓ │ ┌────┴────┐ │ │ QC │ │ └────┬────┘ │ ↓ │ ┌────┴────┐ │ │ plan_ │ │ │confirmation│ │ └────┬────┘ │ ↓ │ ┌────┴────┐ │ │confirm │revise │ ↓ ↓ │ ┌────┐ ┌─────────────────┐ │ │exec│ │ revising_plan │ │ └────┘ └────────┬────────┘ │ ↓ ↓ │ ↓ plan_confirmation │ ↓ │ ┌────┴────┐ │ │ final_ │ │ │ report │ │ └────┬────┘ │ ↓ │ idle ←────────────────────────────────────────┘ ``` --- ## 与其他技能配合 ### 与 re-checker + loop-management 配合 **输入输出（包含记忆传递）**： ```python def send_to_quality_control(user_input: str, project_memory: dict, state: WorkflowState) -> dict: """ 发送到质量控制层 返回: 经过重新确认的问题和状态 """ return { 'input': user_input, 'memory': { 'principles': { 'code': project_memory['principles']['code'], 'process': project_memory['principles']['process'], 'interaction': project_memory['principles']['interaction'] }, 'docs_index': project_memory['docs_index'], 'project_state': project_memory['project_state'] }, 'state': state, 'output': None # 由 re-checker + loop-management 填充 } ``` **完整交互**： ``` workflow-controller ↓ 理解确认 ↓ 等待用户确认 ↓ 加载 IFLOW.md ↓ 发送问题 + 记忆 re-checker + loop-management ↓ 验证是否符合记忆内原则 internal-dispatcher ↓ 处理 任务处理层 ↓ 返回结果 re-checker + loop-management ↓ 评估 + 验证原则 ↓ 传递给 plan_confirmation ┌─────────┴─────────┐ ↓ ↓ 继续循环 结束循环 ↓ ↓ 返回中枢 返回最终答案 ↓ ↓ ┌────┴────┐ ↓ workflow-controller 展示给用户 ``` ### 与 internal-dispatcher 配合 ``` workflow-controller → re-checker + loop-management → internal-dispatcher ↑ ↓ ←─────────────── 返回最终结果 ←────────────────────┘ ``` ### 与 logic-confirmation/designer/docs-builder 配合 每个技能处理完成后，workflow-controller 会进行确认： ``` logic-confirmation 输出理解 ↓ workflow-controller 确认用户理解是否正确 ↓ designer 输出设计思路 ↓ workflow-controller 确认设计思路是否满足需求 ↓ docs-builder 输出详细文档 ↓ workflow-controller 确认文档是否满足需求 ↓ 写入文档 ``` ### 与 test-plan/internal-testing-code-generator 配合 ``` test-plan 输出测试计划 ↓ workflow-controller 展示计划并确认 ↓ 用户确认后 ↓ internal-testing-code-generator 生成内测代码 ↓ workflow-controller 展示代码并确认 ↓ 用户确认后 ↓ 自主执行 ``` ### 与 index-builder 配合 ``` docs-builder 输出文档 ↓ workflow-controller 调用 index-builder ↓ index-builder 更新 IFLOW.md 索引 ↓ workflow-controller 继续流程 ``` --- ## 工作流历史记录 ### 自动记录 ```python def record_workflow_history(skill_name: str, action: str, state: dict) -> None: """记录工作流历史""" log_entry = { 'timestamp': get_current_timestamp(), 'skill': skill_name, 'action': action, 'state': state, 'memory_used': state.project_memory.get('principles', {}) } append_to_workflow_log(log_entry) ``` ### 历史记录格式 ```log #======================================== # 工作流日志 #======================================== 时间: 2026-01-24 10:30:00 输入: 我希望设计一个能够绘制UMAP聚类图象的程序 理解确认: 已确认 记忆加载: IFLOW.md 已加载 - 全局原则数量: 3 - 文档索引数量: 5 计划确认: 已确认 阶段: understanding → quality_control → plan_confirmation → execution → final 当前技能: workflow-controller 动作: 接收最终结果并展示给用户 #======================================== ``` --- ## 输出产物 - 理解确认请求消息 - 计划确认请求消息 - 确认状态管理 - 状态更新指令 - 下一步分发决策 - 工作流历史记录 - 传递给 re-checker 的记忆上下文 --- ## 使用方法 ### 手动触发 ```markdown 用户: [需要workflow-controller介入的场景] → workflow-controller 接收 → 展示理解确认 → 等待用户确认 → 自动加载 IFLOW.md → 根据类型分发到质量控制层或直接处理 ``` ### 自动介入 在以下情况自动介入： - 用户输入新问题 - 理解确认阶段 - 计划确认阶段 - 技能处理完成需要确认 - 需要用户决策的节点 ### 交互示例 **新问题流程**： ```markdown 用户: 我希望设计一个UMAP聚类程序 → workflow-controller 接收 → 展示理解确认 → 等待用户确认 → 用户输入"1" → 自动加载 IFLOW.md 记忆 → 发送到 re-checker + loop-management → ... → 返回最终结果 ``` **理解确认流程**： ```markdown --- ## 理解确认 我的理解是： 1. 您希望设计一个UMAP聚类程序 2. 程序需要支持数据导入 3. 程序需要支持参数配置 请确认： - 输入 **1** 或 **确认** → 以上理解正确，继续执行 - 输入 **否** → 以上理解有误，请提供修改意见 --- ``` **计划确认流程**： ```markdown --- ## 计划确认 **测试计划内容**： - 第一轮：基础功能测试 - 第二轮：边界条件测试 - 第三轮：集成测试 **代码预览**： ```python # UMAP聚类程序 import umap import matplotlib.pyplot as plt ... ``` 请确认： - 输入 **1** 或 **确认** → 以上计划满足要求，继续执行 - 输入 **否** → 以上计划有误，请提供修改意见 --- ``` --- ## 关键改进点 | 改进项 | 之前 | 现在 | |-------|------|------| | 理解确认 | 无 | 用户输入任何任务请求时必须先展示理解确认 | | 计划确认 | 无 | 生成测试计划、代码前必须展示并等待确认 | | 记忆加载 | 自动加载 | 保持自动加载 IFLOW.md | | 记忆传递 | 传递给 re-checker | 保持传递给 re-checker | | 原则验证 | re-checker 验证 | 保持 re-checker 验证 | | 执行过程 | 需每轮确认 | 用户确认后保持自主执行 | | 索引更新 | IFLOW.md | 保持 IFLOW.md 索引更新 | --- ## 与 AGENTS.md 的关系 本技能与 `/home/hrply/.iflow/AGENTS.md` 中描述的四层架构保持一致： - **第一层：交互层** - workflow-controller 位于此层 - **第二层：理解确认层** - logic-confirmation, designer, docs-builder - **第三层：调度层** - internal-dispatcher, loop-management, re-checker - **第四层：执行层** - test-plan, syntax-checker, issue-discovery 等 workflow-controller 作为交互层核心，确保： 1. 用户输入经过理解确认 2. 计划经过确认后才能执行 3. 确认后执行过程保持自主