implement

实现功能

与宿主无关的工作流。通过技能名称（implement）调用。Claude Code 斜杠路由、YAML 钩子加载器和 .claude/chain 的说明见 references/claude-code.md。

通过并行子 Agent 执行功能实现，并控制范围、进行反思。

快速开始

implement user authentication
implement --model=opus real-time notifications
implement dashboard analytics

---

参数解析

首先检查目标，然后再执行任何其他步骤。 此技能会分叉运行，无法查看对话内容。加载 Read("../../shared/rules/target-resolution.md")：如果去掉标志后的目标是单独的代词或指示词（this、them、that one），或目标为空，则原样返回 TARGET_UNRESOLVED: <word> 并停止。调用方会解析目标并重新调用。

FEATURE_DESC = "$ARGUMENTS"  # Full argument string, e.g., "user authentication"
# $ARGUMENTS[0] is the first token, $ARGUMENTS[1] second, etc. (CC 2.1.59)

# Model override detection (CC 2.1.72)
MODEL_OVERRIDE = None
for token in "$ARGUMENTS".split():
    if token.startswith("--model="):
        MODEL_OVERRIDE = token.split("=", 1)[1]  # "opus", "sonnet", "haiku", "fable"
        FEATURE_DESC = FEATURE_DESC.replace(token, "").strip()

设置 MODEL_OVERRIDE 时，通过 model=MODEL_OVERRIDE 将其传递给所有 Agent() 调用。可接受符号名称（opus、sonnet、haiku，以及 Agent 工具列表中包含 fable 的运行环境；请注意，2026-07-12 之后，fable 会产生高级 API 费用）或完整 ID（claude-opus-5-5），参见 CC 2.1.74。

---

步骤 -1：MCP 探测 + 恢复检查

在任何其他步骤之前运行。 检测可用的 MCP 服务并检查是否存在可恢复状态。

# Probe MCPs (parallel — all in ONE message):
# memory is alwaysLoad in .mcp.json (CC 2.1.121+, #1541) — probe below kept as fallback for older CC:
ToolSearch(query="select:mcp__memory__search_nodes")
ToolSearch(query="select:mcp__context7__resolve-library-id")

Write(".claude/chain/capabilities.json", JSON.stringify({
  "memory": <true if found>,
  "context7": <true if found>,
  "timestamp": now()
}))

# Resume check:
Read(".claude/chain/state.json")
# If exists and skill == "implement":
#   Read last handoff (e.g., 04-architecture.json)
#   Skip to current_phase
#   "Resuming from Phase {N} — architecture decided in previous session"
# If not: write initial state
Write(".claude/chain/state.json", JSON.stringify({
  "skill": "implement", "feature": FEATURE_DESC,
  "current_phase": 1, "completed_phases": [],
  "capabilities": capabilities,
  "budget_remaining_pct": 100  // advisory; see Budget Awareness below
}))

批次大小管理（大型重构）

对于涉及 10 个以上文件的实现，每个 Agent 批次最多处理 5 个文件，在批次之间运行测试，测试通过的批次立即提交；测试失败则停止。使用 --batch-size N 可覆盖此设置。完整规则：Read("rules/batch-governance.md")。

预算感知（Opus 5.5 任务预算，公开测试版）

Opus 5.5 会公开每项任务的令牌预算。在 CC 端正式发布之前，OrchestKit 会在 state.json 中跟踪建议性的 budget_remaining_pct，以便长时间运行时自动降低资源消耗。每个阶段结束后更新：

# At end of every phase, estimate remaining budget:
pct = tokensAsContextPct(tokensUsedSoFar)  # from lib/context-window.ts
remaining = max(0, 100 - pct)
state["budget_remaining_pct"] = remaining
Write(".claude/chain/state.json", JSON.stringify(state))

剩余预算会影响行为：

剩余预算	行为
> 50%	正常 — 包括所有可选的深入工作（反方论证、视觉捕获、深度探索）。
20-50%	高效 — 跳过可选的深入工作；保留核心阶段。向用户警告一次。
< 20%	节省 — 完成当前阶段，提供包含后续步骤的交接内容，不启动新工作。

CC 的原生任务预算 API 正式发布后，用实际信号替代估算；阈值和行为保持不变。

加载：Read("../chain-patterns/references/checkpoint-resume.md")

---

步骤 -0.5：评估结果门控

如果 .claude/chain/assess-verdict.json 存在，其中的 feature 与本次运行匹配，且 verdict == "fail"（综合评分低于 ../assess/rubric.json 中的 5.5 min_pass，或任一维度低于其 min_blocker），则阻止阶段 1。展示每个 blockers[] 条目（维度、分数、原因），然后使用纯标签+描述选项（不含 preview）调用 AskUserQuestion：

1. 先修复阻碍项（推荐） — 解决阻碍项，重新运行 assess，然后返回此处。
2. 覆盖并实现 — 继续执行；在 state.json 中记录 "assess_gate": "overridden"，并将阻碍项纳入阶段 1 上下文。

文件缺失或 verdict == "pass" → 不启用门控；继续执行步骤 0。

---

步骤 0：按工作量缩放阶段（CC 2.1.76；2.1.111 中新增 xhigh）

读取 /effort 设置，以此调整实现深度。工作量感知型上下文预算钩子会自动检测工作量级别 — 相应调整阶段计划：

工作量级别	运行阶段	Agent 数量	令牌预算
low	1（探索）→ 5（实现）→ 10（反思）	最多 2 个	~50K
medium	1 → 2 → 5 → 7（范围蔓延）→ 10	最多 3 个	~150K
high	全部 10 个阶段	4-7 个	~400K
xhigh（Opus 5，CC 2.1.111+）	全部 10 个阶段 + 测试失败时，在升级处理前额外进行一次修复迭代	4-7 个	~550K

覆盖规则： 步骤 0 中用户的明确选择（例如“先规划”或“Worktree”）优先于 /effort 降级。若用户要求完整探索，无论工作量级别如何，都应遵照执行。low 仅适用于规范完整、流程机械的工作；低工作量运行始终会将任务移交给高工作量的 /ork:verify：Read("references/effort-ladder.md")。

步骤 0a：项目上下文发现

开始任何工作之前，检测项目层级。这将成为所有模式的复杂度上限。

扫描代码库信号，并将其划分为 1–6 级（从访谈到开源）。每个层级都会设定架构上限，并决定使用哪些阶段/Agent。

加载层级详情、工作流映射和编排模式：Read("references/tier-classification.md")

加载项目上下文。 分叉技能不会运行 frontmatter 钩子（#4683），因此请自行运行加载器，并牢记其 additionalContext：

echo '{"tool_name":"Bash","tool_input":{}}' | node "${CLAUDE_PLUGIN_ROOT}/hooks/bin/run-hook.mjs" skill/project-convention-loader
echo '{"tool_name":"Bash","tool_input":{}}' | node "${CLAUDE_PLUGIN_ROOT}/hooks/bin/run-hook.mjs" skill/implement-standards-loader
git rev-parse HEAD  # note it as the start sha for the Phase 6 pattern check

工作树隔离（CC 2.1.49）

对于涉及 5 个或更多文件的功能，提供工作树隔离，以防与主工作树发生冲突：

AskUserQuestion(questions=[{
  "question": "Isolate this feature in a git worktree?",
  "header": "Isolation",
  "options": [
    {"label": "Yes — worktree (Recommended)", "description": "Creates isolated branch via EnterWorktree, merges back on completion"},
    {"label": "No — work in-place", "description": "Edit files directly in current branch"},
    {"label": "Plan first", "description": "Research and design in plan mode before writing code"}
  ],
  "multiSelect": false
}])

如果选择了“先规划”：

# 1. Enter read-only plan mode
EnterPlanMode("Research and design: $ARGUMENTS")

# 2. Research phase — Read/Grep/Glob ONLY, no Write/Edit
#    - Read existing code in the target area
#    - Grep for related patterns, imports, dependencies
#    - Check tests, configs, and integration points
#    - If context7 available: query library docs

# 3. Design the plan — produce:
#    - File map: which files to create/modify
#    - Architecture decisions with rationale
#    - Task breakdown with acceptance criteria
#    - Risk assessment and edge cases

# 4. Exit plan mode — returns plan to user for approval
ExitPlanMode()

# 5. User reviews plan. If approved → continue to Phase 1 (Discovery)
#    with the plan as input. If rejected → revise or stop.

如果选择了工作树：

1. 调用 EnterWorktree(name: "feat-{slug}") 创建隔离分支
2. 所有 Agent 都在工作树目录中工作
3. 完成后合并回去：git checkout {original-branch} && git merge feat-{slug}
4. 如果出现合并冲突，通过 AskUserQuestion 向用户展示差异

加载工作树详情：Read("references/worktree-isolation-mode.md")

---

步骤 0b：影响范围澄清（先问“是什么”，再问“怎么做”）

进入阶段 1 之前，按影响范围顺序解决那些答案会改变架构的未知问题——架构/迁移 → 身份验证 → API 契约 → 性能/规模 → 外观（最后）。先用 grep 搜索，再逐个调用 AskUserQuestion（优先询问影响最大的，最多约 5 个，跳过显而易见的问题）。每个答案都会成为 Decisions 表中的一行，写入 .claude/chain/decisions.json 和 PR 正文，并作为约束传入阶段 4（架构）。如果架构/身份验证问题尚未解决，不要开始阶段 1；在 low 工作量下跳过。完整流程：Read("references/blast-radius-clarification.md")。

---

完成标准。 完成意味着：所有计划中的文件都已编写，新旧测试均已通过，范围蔓延检查未发现任何计划外事项，并且已运行端到端验证。遵循 Read("../../shared/rules/long-run-protocol.md")：当某个步骤不需要用户输入时继续推进；只有在无法继续或即将执行破坏性操作前才停下来询问；接受每个子 Agent 的结果前都要检查其证据；对任何无法确认的事项，标明检查位置。

任务管理（必需）

在做任何其他事情之前，创建任务以跟踪进度：

# 1. Create main task IMMEDIATELY
TaskCreate(
  subject="Implement: {feature}",
  description="Feature implementation with parallel subagents",
  activeForm="Implementing {feature}"
)

# 2. Create subtasks for each phase
TaskCreate(subject="Research best practices and docs", activeForm="Researching best practices")  # id=2
TaskCreate(subject="Micro-plan: scope, files, criteria", activeForm="Micro-planning")            # id=3
TaskCreate(subject="Architecture design (parallel agents)", activeForm="Designing architecture") # id=4
TaskCreate(subject="Implement and write tests", activeForm="Implementing code")                  # id=5
TaskCreate(subject="Integration verification", activeForm="Verifying integration")               # id=6
TaskCreate(subject="Scope creep check", activeForm="Checking scope creep")                       # id=7
TaskCreate(subject="E2E verification", activeForm="Running E2E verification")                    # id=8
TaskCreate(subject="Document and reflect", activeForm="Documenting decisions")                   # id=9

# 3. Set dependencies for sequential phases
TaskUpdate(taskId="3", addBlockedBy=["2"])  # Plan needs research
TaskUpdate(taskId="4", addBlockedBy=["3"])  # Architecture needs plan
TaskUpdate(taskId="5", addBlockedBy=["4"])  # Implementation needs architecture
TaskUpdate(taskId="6", addBlockedBy=["5"])  # Integration needs implementation
TaskUpdate(taskId="7", addBlockedBy=["6"])  # Scope creep needs integration
TaskUpdate(taskId="8", addBlockedBy=["7"])  # E2E needs scope check
TaskUpdate(taskId="9", addBlockedBy=["8"])  # Docs need E2E

# 4. Update status as you progress
TaskUpdate(taskId="2", status="in_progress")  # When starting
TaskUpdate(taskId="2", status="completed")    # When done — repeat for each subtask

工作流（10 个阶段）

阶段	活动	Agent
1. 调研	研究最佳实践、Context7 文档，并拆分任务	—
2. 微观规划	为每项任务制定详细计划（加载 references/micro-planning-guide.md）	—
3. Worktree	对涉及 5 个或更多文件的功能，在 git worktree 中隔离工作（加载 references/worktree-workflow.md）	—
4. 架构设计	4 个并行后台 Agent（事件/CQRS/队列类任务还需 event-driven-architect）	workflow-architect、backend-system-architect、frontend-ui-developer、llm-integrator
5. 实现 + 测试	并行 Agent，一次性产出制品并强制要求测试	backend-system-architect、frontend-ui-developer、llm-integrator、test-generator
6. 集成验证	代码审查 + 真实服务集成测试	backend、frontend、code-quality-reviewer、security-auditor
7. 范围蔓延检查	比较计划与实际情况（加载 references/scope-creep-detection.md）	workflow-architect
8. E2E 验证	浏览器 + API E2E 测试（加载 references/e2e-verification.md）	—
9. 文档	将决策保存到记忆图谱	—
10. 复盘	总结经验教训，评估估算准确性	workflow-architect

加载 Agent 提示词：Read("references/agent-phases.md")

阶段 6 模式检查。 该分支无法在 Write/Edit 时运行强制检查器（#4683）；按 Read("references/phase-6-pattern-check.md") 中的说明，将每个变更文件传入 node "${CLAUDE_PLUGIN_ROOT}/hooks/bin/run-hook.mjs" skill/pattern-consistency-enforcer，每个文件运行一次。

Agent Teams 模式：Read("references/agent-teams-phases.md")

嵌套委派（CC 2.1.172+）： 阶段 4–6 的专业 Agent 可以被要求将范围明确的子问题委派给其声明的子 Agent（例如 backend-system-architect 将架构设计委派给 database-engineer），而不是全部自行完成。委派链最多 3 层；子任务相互独立时，应由此编排器将其平铺为并行任务。参见 chain-patterns 中的模式 9（CC 2.1.172+）。

阶段交接（CC 2.1.71）

在主要阶段结束后写入交接 JSON。结构参见 chain-patterns 技能。

阶段结束后	交接文件	关键产出
1. 调研	01-discovery.json	最佳实践、库文档、任务拆分
2. 微观规划	02-plan.json	文件映射、每项任务的验收标准
4. 架构设计	04-architecture.json	决策、选用的模式、Agent 结果
5. 实现	05-implementation.json	新建/修改的文件、测试结果
7. 范围蔓延检查	07-scope.json	计划与实际情况、PR 拆分建议

渐进式输出（CC 2.1.76+）

每个阶段结束后逐步输出结果，不要等到最后才一次性汇总。

专注模式（CC 2.1.101）： 在专注模式（/focus）下，用户只能看到你的最终消息。请提供包含所有关键结果的完整摘要，不要假设用户看到了渐进式输出。

阶段结束后	向用户展示
1. 调研	关键发现、库推荐、任务拆分
4. 架构设计	各 Agent 返回时提供其设计决策
5. 实现	各 Agent 新建/修改的文件、测试结果
7. 范围蔓延检查	计划与实际情况的差异、PR 拆分建议

当 Agent 以 run_in_background=true 运行时，每个 Agent 返回后应立即输出其发现，不要等待所有 Agent 完成。这样能让用户感受到的反馈速度提升约 60%，并在 Agent 的方案偏离计划时及时介入。

队友的后台任务会在轮次结束后继续运行（CC 2.1.183）： 队友启动的 run_in_background 任务在该队友结束轮次后不会再被终止。并行的架构/测试队友可以启动耗时构建任务，让任务在自身轮次结束后继续运行；负责人稍后再收集结果。在 CC 2.1.183 之前，负责人必须拥有每个后台任务才能让其持续运行。

后台流式传输监控工具（CC 2.1.98）

使用 Monitor 从后台构建／测试脚本中流式获取实时事件，而不是轮询输出文件：

# Start a long-running build in background
Bash(command="npm run build 2>&1", run_in_background=true)
# Stream its output line-by-line as notifications (no polling)
Monitor(pid=build_task_id)

# For background agents with test suites:
Agent(subagent_type="ork:test-generator", run_in_background=true, isolation="worktree", ...)
# Monitor agent progress via task notifications (CC 2.1.98 partial progress)

完整模式参考（何时使用 Monitor 而不是 TaskOutput、直到条件门控、部分结果挽救、反模式）：Read("../chain-patterns/references/monitor-patterns.md")。

**部分结果（CC 2.1.98）：**如果工作树隔离的 Agent 在实现过程中崩溃，请挽救其部分输出——在其工作树中运行 git diff --name-only，提交可用内容，并标记未完成事项——而不是重新生成；将处于 BLOCKED 状态的 Agent 上报给用户。完整的挽救逻辑见上面的 monitor-patterns 参考文档。

工作树隔离实现

**使用 Agent(isolation="worktree") 生成并行实现 Agent。**子 Agent 绕过工作树隔离保护的问题已在 CC 2.1.154 中修复，并于 2.1.203 完成；ork 的最低版本为 >= 2.1.220，因此每个受支持的会话都会获得真正的隔离。完整模式，以及 2.1.206 中关于 EnterWorktree 现在会针对 ork 的树外 ../<repo>-<task> 约定要求确认的注意事项： Read("../chain-patterns/references/worktree-agent-pattern.md")

*历史记录（仅适用于 CC <= 2.1.153）：*该参数会扰乱主工作树的 HEAD，并在约 60 次工具调用后切断 Agent（Yonatan-HQ/platform#3224）。曾解决此问题的手动预创建变通方案现已被取代，仅作为记录保留： references/manual-worktree-pattern.md。

部署后监控（CC 2.1.71）

最终 PR 完成后，安排健康状况监控：

# Guard: Skip cron in headless/CI (CLAUDE_CODE_DISABLE_CRON)
# if env CLAUDE_CODE_DISABLE_CRON is set, run a single check instead
CronCreate(
  schedule="0 */6 * * *",
  prompt="Health check for {feature} in PR #{pr}:
    gh pr checks {pr} --repo {repo}.
    If healthy 24h → CronDelete. If errors → alert."
)

使用检测功能的 context7

if capabilities.context7:
  mcp__context7__resolve-library-id({ libraryName: "next-auth" })
  mcp__context7__query-docs({ libraryId: "...", query: "..." })
else:
  WebFetch("https://docs.example.com/api")  # T1 fallback

问题跟踪

如果正在处理 GitHub issue，请执行 issue-progress-tracking 中的 Start Work 流程，并在重要阶段结束后发布进度评论。

反馈循环

在每项任务后设置检查点。加载触发条件：Read("references/feedback-loop.md")

---

测试要求矩阵

第 5 阶段的测试生成器 MUST 生成与变更类型相匹配的测试。每种变更类型都对应特定的必需测试和测试规则。

加载测试矩阵、真实服务检测和第 9 阶段门控：Read("references/test-requirements-matrix.md")

---

核心原则

• 验证门控（终端，强制）——在声明任何任务完成之前，MUST Read("../../shared/rules/verification-gate.md") 并满足每项检查：验证每个变更文件、测试通过、评估范围蔓延。部分通过不算完成；“现在应该能用了”不是证据。
• Agent 状态协议——所有子 Agent 都应按照 Read("../../shared/status-protocol.md") 报告 DONE / DONE_WITH_CONCERNS / BLOCKED / NEEDS_CONTEXT
• 测试不可省略——每项任务都包含与变更类型匹配的测试（见上方矩阵）
• 独立任务并行处理——使用 run_in_background: true，在同一条消息中启动所有 Agent
• **输出限制（CC 2.1.77+）：**Opus 层级默认输出令牌数为 64k（上限为 128k）。尽可能一次性生成完整产物；如果输出超出限制，则分多轮生成
• 实现前制定微型计划——明确范围边界、文件列表和验收标准
• 检测范围蔓延（第 7 阶段）——评分 0-10；如果影响显著，则拆分 PR
• 有真实服务可用时使用真实服务——如果存在 docker-compose/testcontainers，则在第 6 阶段使用它们
• 复盘并记录经验（第 10 阶段）——持久化到记忆图谱
• 清理 Agent——队友会在轮次结束时退出（CC 2.1.178+ 隐式团队）；按两次 Ctrl+F 停止仍在运行的后台 Agent。注意：/clear（CC 2.1.72+）会保留后台 Agent
• 退出工作树——如果在第 0 步进入了工作树，则在第 10 阶段调用 ExitWorktree(action: "keep")；绝不能遗留孤立工作树

---

后续步骤（实现后向用户建议）

verify {FEATURE}              # Grade the implementation
cover {FEATURE}               # Generate test suite
commit                        # Commit changes
/loop 10m npm test                 # Watch tests while iterating
/loop 30m verify {FEATURE}    # Periodic quality gate

完成后推送通知（CC 2.1.110+）

implement 运行通常需要 10–30 分钟，并会使用并行 Agent。在最终汇总步骤中，PR 已创建且测试通过后，调用 PushNotification——用户几乎肯定已经切换了上下文。

PushNotification(
  message=f"ork:implement complete — {FEATURE}: {tests_passing}/{tests_total} tests · PR #{pr_num} opened · ready for verify",
  status="proactive"
)

完整规则（何时触发、正文内容限制，以及对没有 Remote Control 的用户如何优雅降级）：加载 Read("../chain-patterns/rules/push-notification-on-completion.md")。

Agent 协调

分派规范（CC 2.1.142+ 标志 — M146-6 / #1849）

分派子 Agent 时——无论是通过会话内的 Agent 工具，还是通过包装脚本运行无头 claude -p --bare——都要根据每个 Agent 的角色设置明确的 --permission-mode 和 --effort，以确保交互式运行与 CI 运行的行为确定一致：

Agent 角色	--permission-mode	--effort	原因
只读分析（Explore、code-quality-reviewer、debug-investigator）	dontAsk	low	不写入，无风险；尽量降低成本。
测试生成（test-generator）	acceptEdits	medium	会写入测试文件；权限提示会阻塞并行扫描。
生产代码（frontend-ui-developer、backend-system-architect）	default 或 acceptEdits	medium 到 high	根据功能复杂度设置。default 会让用户参与其中。
绝不使用	bypassPermissions	—	跳过审计记录——仅可在一次性沙盒中使用。

会话内的 Agent 工具调用会继承父会话的权限模式；此表是关于这些默认值应如何设置的策略。对于真正的无头调用（cron、CI），请将标志显式传给 claude -p --bare：

claude -p --bare \
  --permission-mode dontAsk \
  --effort low \
  --max-turns 8 \
  "<prompt>"

传递上下文

所有生成的 Agent 都会收到：变更文件列表、项目层级、架构约束，以及前序阶段（探索、计划）作出的决策。通过 Agent 提示词传递，不要只说“实现 X”。

SendMessage（主动协调）

跨会话回复会发送到父会话（CC 2.1.248）： 子 Agent 向另一会话发送 SendMessage 时，回复会送达父会话的对话中，而不会送达子 Agent；子 Agent 发出消息后继续执行，父会话读取回复。跨会话的 SendMessage / ListAgents 在 Bedrock、Vertex 和 Foundry 上以及禁用遥测时也可用（CC 2.1.248）。

当后端和前端 Agent 需要对齐 API 契约时：

SendMessage(to="frontend-ui-developer", message="API endpoint is POST /api/auth with {token, refreshToken} response shape")
SendMessage(to="test-generator", message="Backend uses JWT — mock auth middleware in test fixtures")

技能链

实现完成后，接续到验证环节：

TaskCreate(subject="Verify implementation", activeForm="Verifying changes")
TaskUpdate(taskId=verify_id, addBlockedBy=[impl_task_id])
# Then: verify {feature}

质量标准

满足以下所有条件才算完成：

• 每个变更文件都通过终端验证关卡验证——绝不能只说“应该能用”
• 第 5 阶段的每项任务都附带与变更类型相匹配的测试；测试套件运行通过，并引用汇总行
• 在第 7 阶段为范围蔓延打分（0–10）；差异显著时拆分 PR
• 第 0 步进入的工作树都通过 ExitWorktree 退出——不得遗留孤立工作树

相关技能

• ork:explore：实现前探索代码库
• ork:verify：验证实现是否正常工作
• ork:issue-progress-tracking：使用提交进度自动更新 GitHub issue

参考资料

按需使用 Read("references/<file>") 加载：

文件	内容
agent-phases.md	Agent 提示词和生成模板
agent-teams-phases.md	Agent Teams 模式阶段
interview-mode.md	面试／带回家完成的任务约束
blast-radius-clarification.md	步骤 0b：先问影响范围、再问实现方式的访谈 + 决策表
orchestration-modes.md	Agent 工具与 Agent Teams 的选择
feedback-loop.md	检查点触发条件和操作
cc-enhancements.md	特定 CC 版本的功能
agent-teams-full-stack.md	团队全栈流水线
team-worktree-setup.md	团队 worktree 配置
micro-planning-guide.md	详细的微观规划指南
scope-creep-detection.md	计划与实际情况对比
worktree-workflow.md	Git worktree 工作流
e2e-verification.md	浏览器 + API 端到端测试指南
worktree-isolation-mode.md	worktree 隔离详情
tier-classification.md	层级分类、工作流映射和编排模式
test-requirements-matrix.md	按变更类型划分的测试矩阵、真实服务检测和阶段 9 门槛