workflow-loop 0.1.0__py3-none-any.whl

workflow_loop/spike_validation.py

@@ -0,0 +1,379 @@
+import os
+import re
+from dataclasses import dataclass
+
+from . import artifact_paths as artifact_paths_mod
+from . import state as state_mod
+from . import verification as verification_mod
+
+
+FIELD_RE = re.compile(r"^- ([^：\n]+)：\s*(.*)$")
+INDEX_ITEM_RE = re.compile(r"^## (SP-\d{3})\s+(.+?)\s*$")
+DETAIL_SECTION_RE = re.compile(r"^## ([1-8])\.\s+(.+?)\s*$")
+MARKDOWN_LINK_RE = re.compile(r"\[[^\]]+\]\(([^)]+)\)")
+PLACEHOLDER_RE = re.compile(r"<[^>\n]+>")
+
+INDEX_REQUIRED_FIELDS = [
+    "真实场景",
+    "要验证的不确定性",
+    "验证结果用于决定什么",
+    "结论文档",
+    "穿刺状态",
+    "是否阻塞后续",
+    "产品设计影响",
+    "代码设计影响",
+    "后续处理阶段",
+]
+
+EXPECTED_DETAIL_SECTIONS = {
+    "1": "真实场景与不确定性",
+    "2": "验证结果用于决定什么",
+    "3": "已知事实与验证范围",
+    "4": "验证方法",
+    "5": "实际执行记录",
+    "6": "实际观察结果",
+    "7": "结论",
+    "8": "对后续工作的影响",
+}
+
+METHOD_FIELDS = ["使用的方法", "临时内容位置", "执行步骤", "外部影响"]
+EXECUTION_FIELDS = ["执行时间", "运行环境", "实际命令", "真实输入或样本", "执行失败"]
+RESULT_FIELDS = ["结果状态", "是否阻塞后续", "已确认内容", "仍未确认内容"]
+IMPACT_FIELDS = [
+    "产品设计影响",
+    "产品设计更新位置",
+    "代码设计影响",
+    "代码设计更新位置",
+    "剩余风险",
+    "后续处理阶段",
+    "后续需要检查什么",
+]
+
+INDEX_STATUSES = {"待验证", "已确认", "限制已确认", "仍未确认"}
+RESULT_STATUSES = {"已确认", "限制已确认", "仍未确认"}
+YES_NO = {"是", "否"}
+DESIGN_IMPACTS = {"需要修改", "无需修改"}
+FOLLOW_UP_STAGES = {
+    "无",
+    "acceptance_plan",
+    "test_plan",
+    "impl",
+    "test_code",
+    "test_execution",
+    "topic_acceptance",
+    "regression_test",
+    "overall_acceptance",
+    "update_code_design",
+}
+
+
+@dataclass
+class SpikeIndexItem:
+    item_id: str
+    name: str
+    fields: dict[str, str]
+
+
+@dataclass
+class SpikeDetail:
+    metadata: dict[str, str]
+    sections: dict[str, str]
+    section_fields: dict[str, dict[str, str]]
+
+
+def _read_text(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def _parse_fields(lines: list[str], context: str) -> tuple[dict[str, str], list[str]]:
+    fields: dict[str, str] = {}
+    errors = []
+    for line in lines:
+        match = FIELD_RE.match(line.strip())
+        if not match:
+            continue
+        key, value = match.groups()
+        if key in fields:
+            errors.append(f"{context} 重复字段：{key}")
+            continue
+        fields[key] = value.strip()
+    return fields, errors
+
+
+def _missing_or_placeholder(value: str | None) -> bool:
+    if value is None or not value.strip():
+        return True
+    return PLACEHOLDER_RE.search(value) is not None
+
+
+def _require_fields(fields: dict[str, str], required: list[str], context: str) -> list[str]:
+    errors = []
+    for key in required:
+        if key not in fields:
+            errors.append(f"{context} 缺少字段：{key}")
+        elif _missing_or_placeholder(fields[key]):
+            errors.append(f"{context} 字段未填写：{key}")
+    return errors
+
+
+def parse_spike_index(path: str) -> tuple[str | None, list[SpikeIndexItem], list[str]]:
+    lines = _read_text(path).splitlines()
+    item_starts = []
+    for index, line in enumerate(lines):
+        match = INDEX_ITEM_RE.match(line.strip())
+        if match:
+            item_starts.append((index, match.group(1), match.group(2).strip()))
+
+    errors = []
+    top_end = item_starts[0][0] if item_starts else len(lines)
+    top_fields, top_errors = _parse_fields(lines[:top_end], "穿刺清单")
+    errors.extend(top_errors)
+    workflow_id = top_fields.get("工作流编号")
+    if _missing_or_placeholder(workflow_id):
+        errors.append("穿刺清单缺少有效的工作流编号")
+
+    items = []
+    seen_ids = set()
+    for position, (start, item_id, name) in enumerate(item_starts):
+        end = item_starts[position + 1][0] if position + 1 < len(item_starts) else len(lines)
+        fields, field_errors = _parse_fields(lines[start + 1:end], f"穿刺项 {item_id}")
+        errors.extend(field_errors)
+        if item_id in seen_ids:
+            errors.append(f"穿刺清单重复编号：{item_id}")
+        seen_ids.add(item_id)
+        errors.extend(_require_fields(fields, INDEX_REQUIRED_FIELDS, f"穿刺项 {item_id}"))
+        items.append(SpikeIndexItem(item_id=item_id, name=name, fields=fields))
+
+    if not items:
+        errors.append("穿刺清单中没有任何穿刺项")
+    return workflow_id, items, errors
+
+
+def parse_spike_detail(path: str) -> tuple[SpikeDetail, list[str]]:
+    lines = _read_text(path).splitlines()
+    section_starts = []
+    for index, line in enumerate(lines):
+        match = DETAIL_SECTION_RE.match(line.strip())
+        if match:
+            section_starts.append((index, match.group(1), match.group(2).strip()))
+
+    errors = []
+    top_end = section_starts[0][0] if section_starts else len(lines)
+    metadata, metadata_errors = _parse_fields(lines[:top_end], os.path.basename(path))
+    errors.extend(metadata_errors)
+    errors.extend(_require_fields(metadata, ["工作流编号", "穿刺项编号"], os.path.basename(path)))
+
+    sections: dict[str, str] = {}
+    section_fields: dict[str, dict[str, str]] = {}
+    for position, (start, number, title) in enumerate(section_starts):
+        end = section_starts[position + 1][0] if position + 1 < len(section_starts) else len(lines)
+        if number in sections:
+            errors.append(f"{os.path.basename(path)} 重复章节：{number}")
+            continue
+        expected_title = EXPECTED_DETAIL_SECTIONS.get(number)
+        if expected_title != title:
+            errors.append(
+                f"{os.path.basename(path)} 第 {number} 章标题应为“{expected_title}”，实际为“{title}”"
+            )
+        body_lines = lines[start + 1:end]
+        body = "\n".join(body_lines).strip()
+        sections[number] = body
+        fields, field_errors = _parse_fields(body_lines, f"{os.path.basename(path)} 第 {number} 章")
+        section_fields[number] = fields
+        errors.extend(field_errors)
+
+    for number, title in EXPECTED_DETAIL_SECTIONS.items():
+        if number not in sections:
+            errors.append(f"{os.path.basename(path)} 缺少第 {number} 章“{title}”")
+            continue
+        body = sections[number]
+        if not body or PLACEHOLDER_RE.search(body):
+            errors.append(f"{os.path.basename(path)} 第 {number} 章未填写完成")
+
+    errors.extend(_require_fields(section_fields.get("4", {}), METHOD_FIELDS, f"{os.path.basename(path)} 第 4 章"))
+    errors.extend(_require_fields(section_fields.get("5", {}), EXECUTION_FIELDS, f"{os.path.basename(path)} 第 5 章"))
+    errors.extend(_require_fields(section_fields.get("7", {}), RESULT_FIELDS, f"{os.path.basename(path)} 第 7 章"))
+    errors.extend(_require_fields(section_fields.get("8", {}), IMPACT_FIELDS, f"{os.path.basename(path)} 第 8 章"))
+
+    observation = sections.get("6", "").strip()
+    if observation in {"无", "暂无"}:
+        errors.append(f"{os.path.basename(path)} 第 6 章必须记录实际观察结果")
+
+    return SpikeDetail(metadata=metadata, sections=sections, section_fields=section_fields), errors
+
+
+def _detail_path_from_link(project_root: str, value: str) -> tuple[str | None, str | None]:
+    match = MARKDOWN_LINK_RE.search(value)
+    if not match:
+        return (None, "结论文档字段必须使用 Markdown 链接")
+    target = match.group(1).split("#", 1)[0].strip()
+    if os.path.isabs(target):
+        return (None, "结论文档不能使用绝对路径")
+
+    if target.startswith("./"):
+        target = target[2:]
+    if target.startswith("spec/"):
+        rel_path = os.path.normpath(target)
+    else:
+        rel_path = os.path.normpath(os.path.join("spec", target))
+
+    if rel_path.startswith(".."):
+        return (None, "结论文档路径不能离开 spec/ 目录")
+    # 结论文档使用稳定中文文件标识：spec/穿刺_<穿刺项文件标识>.md
+    normalized = rel_path.replace(os.sep, "/")
+    if not re.fullmatch(r"spec/穿刺_[A-Za-z0-9_\-一-鿿㐀-䶿]+\.md", normalized):
+        return (None, "结论文档文件名必须是 spec/穿刺_<穿刺项文件标识>.md")
+    if normalized == artifact_paths_mod.SPIKE_INDEX_DOC:
+        return (None, "穿刺清单不能作为结论文档")
+    return (rel_path, None)
+
+
+def _validate_choice(value: str | None, allowed: set[str], label: str, context: str) -> list[str]:
+    if value not in allowed:
+        return [f"{context} 的“{label}”值无效：{value or '空'}"]
+    return []
+
+
+def _is_none_value(value: str | None) -> bool:
+    return value is None or not value.strip() or value.strip() in {"无", "暂无"}
+
+
+def validate_spike_stage(project_root: str) -> tuple[bool, str]:
+    state = state_mod.load_state(project_root)
+    if state is None:
+        return (False, "找不到当前工作流状态")
+
+    index_path = os.path.join(project_root, artifact_paths_mod.SPIKE_INDEX_DOC)
+    if not os.path.exists(index_path):
+        return (False, f"{artifact_paths_mod.SPIKE_INDEX_DOC} 不存在")
+
+    workflow_id, items, errors = parse_spike_index(index_path)
+    if workflow_id and workflow_id != state.workflow_id:
+        errors.append(
+            f"穿刺清单属于工作流 {workflow_id}，当前工作流是 {state.workflow_id}"
+        )
+
+    seen_detail_paths = set()
+    product_design_needs_change = False
+    code_design_needs_change = False
+
+    for item in items:
+        context = f"穿刺项 {item.item_id}"
+        fields = item.fields
+        if any(key not in fields or _missing_or_placeholder(fields.get(key)) for key in INDEX_REQUIRED_FIELDS):
+            continue
+
+        errors.extend(_validate_choice(fields.get("穿刺状态"), INDEX_STATUSES, "穿刺状态", context))
+        if fields.get("穿刺状态") == "待验证":
+            errors.append(f"{context} 仍是待验证，不能通过门2")
+        errors.extend(_validate_choice(fields.get("是否阻塞后续"), YES_NO, "是否阻塞后续", context))
+        errors.extend(_validate_choice(fields.get("产品设计影响"), DESIGN_IMPACTS, "产品设计影响", context))
+        errors.extend(_validate_choice(fields.get("代码设计影响"), DESIGN_IMPACTS, "代码设计影响", context))
+        errors.extend(_validate_choice(fields.get("后续处理阶段"), FOLLOW_UP_STAGES, "后续处理阶段", context))
+
+        detail_rel_path, link_error = _detail_path_from_link(project_root, fields["结论文档"])
+        if link_error:
+            errors.append(f"{context}：{link_error}")
+            continue
+        assert detail_rel_path is not None
+        if detail_rel_path in seen_detail_paths:
+            errors.append(f"多个穿刺项使用同一份结论文档：{detail_rel_path}")
+            continue
+        seen_detail_paths.add(detail_rel_path)
+
+        detail_path = os.path.join(project_root, detail_rel_path)
+        if not os.path.exists(detail_path):
+            errors.append(f"{context} 的结论文档不存在：{detail_rel_path}")
+            continue
+
+        detail, detail_errors = parse_spike_detail(detail_path)
+        errors.extend(detail_errors)
+        if detail.metadata.get("工作流编号") != state.workflow_id:
+            errors.append(f"{detail_rel_path} 的工作流编号与当前工作流不一致")
+        if detail.metadata.get("穿刺项编号") != item.item_id:
+            errors.append(f"{detail_rel_path} 的穿刺项编号与清单中的 {item.item_id} 不一致")
+
+        result_fields = detail.section_fields.get("7", {})
+        impact_fields = detail.section_fields.get("8", {})
+        result_status = result_fields.get("结果状态")
+        blocked = result_fields.get("是否阻塞后续")
+        product_impact = impact_fields.get("产品设计影响")
+        code_impact = impact_fields.get("代码设计影响")
+        follow_up = impact_fields.get("后续处理阶段")
+
+        errors.extend(_validate_choice(result_status, RESULT_STATUSES, "结果状态", detail_rel_path))
+        errors.extend(_validate_choice(blocked, YES_NO, "是否阻塞后续", detail_rel_path))
+        errors.extend(_validate_choice(product_impact, DESIGN_IMPACTS, "产品设计影响", detail_rel_path))
+        errors.extend(_validate_choice(code_impact, DESIGN_IMPACTS, "代码设计影响", detail_rel_path))
+        errors.extend(_validate_choice(follow_up, FOLLOW_UP_STAGES, "后续处理阶段", detail_rel_path))
+
+        if fields.get("穿刺状态") != result_status:
+            errors.append(f"{context} 的穿刺状态与结论文档结果状态不一致")
+        if fields.get("是否阻塞后续") != blocked:
+            errors.append(f"{context} 的阻塞状态与结论文档不一致")
+        if fields.get("产品设计影响") != product_impact:
+            errors.append(f"{context} 的产品设计影响与结论文档不一致")
+        if fields.get("代码设计影响") != code_impact:
+            errors.append(f"{context} 的代码设计影响与结论文档不一致")
+        if fields.get("后续处理阶段") != follow_up:
+            errors.append(f"{context} 的后续处理阶段与结论文档不一致")
+
+        if blocked == "是":
+            errors.append(f"{context} 仍然阻塞后续，不能通过门2")
+
+        if result_status == "仍未确认":
+            if _is_none_value(result_fields.get("仍未确认内容")):
+                errors.append(f"{detail_rel_path} 必须写清仍未确认内容")
+            if _is_none_value(impact_fields.get("剩余风险")):
+                errors.append(f"{detail_rel_path} 必须写清剩余风险")
+            if follow_up == "无":
+                errors.append(f"{detail_rel_path} 必须指定后续处理阶段")
+            if _is_none_value(impact_fields.get("后续需要检查什么")):
+                errors.append(f"{detail_rel_path} 必须写清后续需要检查什么")
+
+        if state.intent == "bugfix" and product_impact == "需要修改":
+            errors.append(
+                f"{detail_rel_path} 需要修改产品设计，不能继续 bugfix；请结束当前流程后启动 product_change"
+            )
+        product_location = impact_fields.get("产品设计更新位置")
+        code_location = impact_fields.get("代码设计更新位置")
+        if product_impact == "需要修改":
+            product_design_needs_change = True
+            if _is_none_value(product_location):
+                errors.append(f"{detail_rel_path} 必须写清产品设计更新位置")
+        elif not _is_none_value(product_location):
+            errors.append(f"{detail_rel_path} 产品设计无需修改时，更新位置应写“无”")
+
+        if code_impact == "需要修改":
+            code_design_needs_change = True
+            if _is_none_value(code_location):
+                errors.append(f"{detail_rel_path} 必须写清代码设计更新位置")
+        elif not _is_none_value(code_location):
+            errors.append(f"{detail_rel_path} 代码设计无需修改时，更新位置应写“无”")
+
+    baseline = state.spike_baseline
+    if baseline.captured_at is None:
+        if not baseline.legacy_unavailable:
+            errors.append("穿刺开始时的产品设计和代码设计基线尚未记录")
+        elif product_design_needs_change or code_design_needs_change:
+            errors.append(
+                "当前是缺少入场设计基线的旧工作流，无法证明设计文档在穿刺后发生了变化"
+            )
+    else:
+        current_product_hash, _ = verification_mod.compute_product_design_hash(project_root)
+        current_code_hash = verification_mod.compute_code_design_hash(project_root)
+        if product_design_needs_change:
+            if baseline.product_design_hash is None or current_product_hash is None:
+                errors.append("无法比较产品设计修改前后的哈希")
+            elif baseline.product_design_hash == current_product_hash:
+                errors.append("穿刺结论要求修改产品设计，但产品设计哈希没有变化")
+        if code_design_needs_change:
+            if baseline.code_design_hash is None or current_code_hash is None:
+                errors.append("无法比较代码设计修改前后的哈希")
+            elif baseline.code_design_hash == current_code_hash:
+                errors.append("穿刺结论要求修改代码设计，但代码设计哈希没有变化")
+
+    if errors:
+        return (False, "；".join(errors))
+    return (True, f"穿刺清单和 {len(items)} 份结论文档通过校验")

workflow_loop/stage_materials.py

@@ -0,0 +1,169 @@
+"""阶段材料清单：检查必读文件、生成有序清单和内容指纹。
+
+材料的消费者是 AI：`workflow discuss` 只输出经过存在性和可读性检查的绝对路径、
+用途和读取顺序，不在 stdout 重复正文。程序保存内容指纹，用于发现讨论后材料
+又被修改的情况；指纹和清单记录都只证明程序给出过当时有效的完整清单，
+不能冒充 AI 已经阅读或理解的证明。
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from dataclasses import dataclass, field
+
+# .workflow_loop 目录名（材料相对路径都以它为根）
+WORKFLOW_LOOP_DIRNAME = ".workflow_loop"
+
+# 所有阶段共同的全局必读材料，按顺序排在阶段材料之前。
+# 每项是 (相对 .workflow_loop/ 的路径, 用途说明)。
+GLOBAL_MATERIALS: list[tuple[str, str]] = [
+    (
+        "Standardized_Repository/global/document_writing.md",
+        "全局写作规范：所有阶段的正式文档和回复共同遵守的表达规则",
+    ),
+    (
+        "Standardized_Repository/global/workflow_lifecycle.md",
+        "全局工作流生命周期规范：返回、作废与收工的统一规则",
+    ),
+]
+
+
+class MaterialError(ValueError):
+    """材料缺失、不是普通文件或不可读时抛出；调用方不得登记本次清单。"""
+
+
+@dataclass
+class StageMaterial:
+    """清单中的一份必读材料。"""
+
+    order: int
+    # 相对 .workflow_loop/ 的路径；None 表示该项没有对应文件（明示"无"）
+    relative_path: str | None
+    # 当前操作系统的原生绝对路径；None 表示没有文件
+    absolute_path: str | None
+    # 这份文件的用途
+    purpose: str
+    # 没有文件时的明示说明
+    note: str = ""
+
+
+@dataclass
+class MaterialChecklist:
+    """一个阶段的完整材料清单。"""
+
+    stage_name: str
+    role_title: str
+    role_description: str
+    # 程序按当前状态生成的短阶段任务说明
+    task_text: str
+    # 按读取顺序排列的真实必读文件
+    materials: list[StageMaterial] = field(default_factory=list)
+    # 明示"无"的占位项（该阶段没有对应模板或规范）
+    placeholders: list[StageMaterial] = field(default_factory=list)
+    # 清单内容指纹：覆盖角色说明、阶段任务、全部材料路径与正文
+    fingerprint: str = ""
+
+
+def _validate_material_file(absolute_path: str, relative_path: str) -> str:
+    """检查真实存在、是普通文件且可读；返回文件内容。"""
+    if not os.path.exists(absolute_path):
+        raise MaterialError(f"必读材料不存在: {relative_path}（{absolute_path}）")
+    if not os.path.isfile(absolute_path):
+        raise MaterialError(f"必读材料不是普通文件: {relative_path}（{absolute_path}）")
+    try:
+        with open(absolute_path, "r", encoding="utf-8") as stream:
+            return stream.read()
+    except OSError as exc:
+        raise MaterialError(f"必读材料无法读取: {relative_path}（{exc}）") from exc
+    except UnicodeDecodeError as exc:
+        raise MaterialError(f"必读材料不是可读文本: {relative_path}（{exc}）") from exc
+
+
+def build_checklist(
+    project_root: str,
+    stage_name: str,
+    role_doc: dict | None,
+    task_text: str,
+    stage_specs: list,
+) -> MaterialChecklist:
+    """组装并校验当前阶段的材料清单，计算内容指纹。
+
+    stage_specs 是阶段策略 `materials()` 返回的 MaterialSpec 列表
+    （relative_path 为 None 表示该阶段没有对应材料，明示"无"）。
+    任一文件不满足存在、普通文件、可读时抛 MaterialError，调用方不得登记清单。
+    """
+    role_title = (role_doc or {}).get("role", "")
+    role_description = (role_doc or {}).get("description", "")
+
+    checklist = MaterialChecklist(
+        stage_name=stage_name,
+        role_title=role_title,
+        role_description=role_description,
+        task_text=task_text,
+    )
+
+    # 指纹覆盖：阶段名、角色说明、内置阶段任务、全部材料的路径与正文、占位项
+    digest = hashlib.sha256()
+    digest.update(f"stage:{stage_name}\n".encode("utf-8"))
+    digest.update(f"role:{role_title}\n{role_description}\n".encode("utf-8"))
+    digest.update(f"task:{task_text}\n".encode("utf-8"))
+
+    order = 0
+    all_specs = [
+        (relative_path, purpose, "")
+        for relative_path, purpose in GLOBAL_MATERIALS
+    ] + [
+        (spec.relative_path, spec.purpose, spec.missing_note)
+        for spec in stage_specs
+    ]
+    for relative_path, purpose, missing_note in all_specs:
+        if relative_path is None:
+            checklist.placeholders.append(
+                StageMaterial(
+                    order=-1,
+                    relative_path=None,
+                    absolute_path=None,
+                    purpose=purpose,
+                    note=missing_note or "无",
+                )
+            )
+            digest.update(f"none:{purpose}:{missing_note}\n".encode("utf-8"))
+            continue
+        order += 1
+        # 绝对路径使用当前操作系统的原生格式，可直接交给文件读取工具
+        absolute_path = os.path.abspath(
+            os.path.join(project_root, WORKFLOW_LOOP_DIRNAME, relative_path)
+        )
+        content = _validate_material_file(absolute_path, relative_path)
+        checklist.materials.append(
+            StageMaterial(
+                order=order,
+                relative_path=relative_path,
+                absolute_path=absolute_path,
+                purpose=purpose,
+            )
+        )
+        digest.update(f"file:{relative_path}\n".encode("utf-8"))
+        digest.update(content.encode("utf-8"))
+        digest.update(b"\n")
+
+    checklist.fingerprint = digest.hexdigest()
+    return checklist
+
+
+def compute_fingerprint(
+    project_root: str,
+    stage_name: str,
+    role_doc: dict | None,
+    task_text: str,
+    stage_specs: list,
+) -> str:
+    """只计算当前材料指纹；文件缺失或不可读时同样抛 MaterialError。"""
+    return build_checklist(
+        project_root,
+        stage_name,
+        role_doc,
+        task_text,
+        stage_specs,
+    ).fingerprint

workflow_loop/stages/__init__.py

@@ -0,0 +1,45 @@
+# 导入阶段基类与公共工具，供所有阶段子类继承和复用
+from .base import StageStrategy, clean_spike_tmp
+# 导入工作流中各阶段策略类
+from .stages import (
+    SpecStage,
+    CodeDesignStage,
+    SpikeStage,
+    AcceptancePlanStage,
+    TestPlanStage,
+    ImplStage,
+    TestCodeStage,
+    TestExecutionStage,
+    TopicAcceptanceStage,
+    TestStage,
+    AcceptanceStage,
+    RegressionTestStage,
+    OverallAcceptanceStage,
+    UpdateCodeDesignStage,
+    ProjectDesignInitStage,
+    ReviseCodeDesignStage,
+    ReproduceStage,
+)
+
+# 对外公开的阶段 API 清单，约束 from workflow_loop.stages import * 的导出范围，避免内部实现泄露
+__all__ = [
+    "StageStrategy",
+    "clean_spike_tmp",
+    "SpecStage",
+    "CodeDesignStage",
+    "SpikeStage",
+    "AcceptancePlanStage",
+    "TestPlanStage",
+    "ImplStage",
+    "TestCodeStage",
+    "TestExecutionStage",
+    "TopicAcceptanceStage",
+    "TestStage",
+    "AcceptanceStage",
+    "RegressionTestStage",
+    "OverallAcceptanceStage",
+    "UpdateCodeDesignStage",
+    "ProjectDesignInitStage",
+    "ReviseCodeDesignStage",
+    "ReproduceStage",
+]