quality-verify-implementation-complete

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Verify Implementation Complete

验证实现完成度

Quick Start

快速开始

Before claiming any implementation is "done", run this verification:

bash

undefined

在声称任何实现“已完成”之前，请运行以下验证：

bash

undefined

1. Check if your new module is imported

1. 检查新模块是否已导入

grep -r "from.*your_module import|import.*your_module" src/

2. Check if your functions are called

2. 检查函数是否被调用

grep -r "your_function_name" src/ --include="*.py" | grep -v test | grep -v "def "

3. Run integration verification

3. 运行集成验证

./scripts/verify_integration.sh # If available

./scripts/verify_integration.sh # 如果可用

4. Answer the Four Questions (see below)

4. 回答四个问题（见下文）


If any check fails or you cannot answer all four questions, **the implementation is NOT complete**.


如果任何检查失败，或你无法回答所有四个问题，**则该实现未完成**。

When to Use This Skill

何时使用此技能

Explicit Triggers

显式触发场景

"Verify this implementation is complete"
"Is this code integrated?"
"Check if my code is wired into the system"
"Prove this feature runs"
"Verify integration for [feature/module]"
"Run implementation completeness check"

“验证此实现是否完整”
“这段代码是否已集成？”
“检查我的代码是否已接入系统”
“证明此功能可运行”
“验证[功能/模块]的集成情况”
“运行实现完整性检查”

Implicit Triggers

隐式触发场景

Before marking any task as "done" or "complete"
Before moving an ADR from
```
in_progress/
```
to
```
completed/
```
After creating new Python modules, classes, or functions
After implementing LangGraph nodes, CLI commands, or API endpoints
Before claiming "feature works" or "implementation successful"
When self-reviewing code changes

在将任何任务标记为“已完成”之前
在将ADR从
```
in_progress/
```
移至
```
completed/
```
之前
在创建新的Python模块、类或函数之后
在实现LangGraph节点、CLI命令或API端点之后
在声称“功能可用”或“实现成功”之前
在自我审查代码变更时

Debugging Triggers

调试触发场景

"Why isn't my feature working?" (often it's not integrated)
"Tests pass but feature doesn't run" (classic integration gap)
"Code exists but nothing happens" (orphaned code)
"Feature used to work" (regression - connection removed)

“为什么我的功能无法工作？”（通常是因为未集成）
“测试通过但功能无法运行”（典型的集成缺口）
“代码存在但无任何反应”（孤立代码）
“功能之前可用”（回归问题 - 连接已被移除）

What This Skill Does

此技能的作用

This skill enforces the Creation-Connection-Verification (CCV) Principle by:

Verifying Creation - Confirms artifacts exist (files, tests, types)
Verifying Connection - Confirms artifacts are wired into the system
Verifying Execution - Confirms artifacts execute at runtime
Providing Evidence - Generates proof that all three phases are complete

This skill prevents the ADR-013 failure mode where code was created and tested but never integrated into

builder.py

, causing the feature to never execute despite passing all quality gates.

此技能通过以下方式遵循创建-连接-验证（CCV）原则：

验证创建 - 确认工件存在（文件、测试、类型）
验证连接 - 确认工件已接入系统
验证执行 - 确认工件在运行时可执行
提供证据 - 生成证明上述三个阶段均已完成的材料

此技能可防止ADR-013故障模式：代码已创建并通过测试，但从未集成到

builder.py

中，导致尽管通过了所有质量关卡，功能仍无法执行。

The CCV Principle

CCV原则

The Formula

公式

COMPLETE = CREATION + CONNECTION + VERIFICATION

已完成 = 创建 + 连接 + 验证

The Three Phases

三个阶段

Phase	Proves	Evidence Required
CREATION	Artifact exists	File written, tests pass, types check, linting clean
CONNECTION	Artifact is wired in	Import statement, registration call, configuration entry
VERIFICATION	Artifact executes	Logs showing execution, output observed, state changes confirmed

Missing any phase = Implementation is INCOMPLETE

阶段	验证内容	所需证据
创建	工件存在	文件已编写、测试通过、类型检查通过、代码风格合规
连接	工件已接入系统	导入语句、注册调用、配置项
验证	工件可执行	显示执行情况的日志、可观测的输出、已确认的状态变更

缺少任何一个阶段 = 未完成实现

Why All Three Are Required

为何三个阶段缺一不可

Creation without Connection → Dead code that never runs
Connection without Verification → Unknown if it actually works
Creation + Connection without Verification → Might work, might not, no proof

仅创建未连接 → 永远不会运行的死代码
仅连接未验证 → 无法确定代码是否真正可用
创建+连接但未验证 → 可能可用也可能不可用，无证据支持

The Four Questions Test

四个问题测试

Before claiming "done", you MUST answer ALL FOUR questions:

在声称“已完成”之前，你必须全部回答以下四个问题：

Question 1: How do I trigger this?

问题1：如何触发此功能？

What it means: What user action, CLI command, API call, or system event causes this code to execute?

Examples:

uv run temet-run -a talky -p "analyze code"

```
curl -X POST /api/endpoint
```

from myapp.service import MyService; MyService().method()

If you cannot answer: Feature has no entry point → NOT COMPLETE

含义： 什么用户操作、CLI命令、API调用或系统事件会触发这段代码执行？

示例：

uv run temet-run -a talky -p "analyze code"

```
curl -X POST /api/endpoint
```

from myapp.service import MyService; MyService().method()

如果无法回答： 功能无入口点 → 未完成

Question 2: What connects it to the system?

问题2：它与系统的连接点在哪里？

What it means: Where is the import, registration, or wiring that makes this code reachable?

Examples:

builder.py line 45: from .architecture_nodes import create_review_node

main.py line 12: app.add_command(my_command)

container.py line 67: container.register(MyService)

If you cannot answer: Code is orphaned → NOT COMPLETE

含义： 导入语句、注册调用或配置项位于何处，使这段代码可被访问？

示例：

builder.py 第45行：from .architecture_nodes import create_review_node

main.py 第12行：app.add_command(my_command)

container.py 第67行：container.register(MyService)

如果无法回答： 代码是孤立的 → 未完成

Question 3: What evidence proves it runs?

问题3：有什么证据证明它已执行？

What it means: What logs, traces, or observable output demonstrates execution?

Examples:

[2025-12-07 10:30:45] INFO architecture_review_triggered

✓ Task completed successfully (in CLI output)

```
HTTP 200 OK (in curl response)
```

If you cannot answer: No execution proof → NOT COMPLETE

含义： 什么日志、追踪信息或可观测的输出能证明代码已执行？

示例：

[2025-12-07 10:30:45] INFO architecture_review_triggered

✓ 任务已成功完成（CLI输出中）

```
HTTP 200 OK（curl响应中）
```

如果无法回答： 无执行证据 → 未完成

Question 4: What shows it works correctly?

问题4：有什么能证明它工作正常？

What it means: What output, state change, or behavior proves correct function?

Examples:

state.architecture_review = ArchitectureReviewResult(status=APPROVED)

Database row inserted with expected values

```
File created with correct contents
```

If you cannot answer: No outcome proof → NOT COMPLETE

含义： 什么输出、状态变更或行为能证明功能正常？

示例：

state.architecture_review = ArchitectureReviewResult(status=APPROVED)

数据库中插入了符合预期值的行
创建了内容正确的文件

如果无法回答： 无结果证据 → 未完成

Step-by-Step Verification Process

分步验证流程

Phase 1: Verify Creation (Artifacts Exist)

阶段1：验证创建（工件存在）

Run standard quality gates:

bash

undefined

运行标准质量关卡：

bash

undefined

Type checking

类型检查

uv run mypy src/

Linting

代码风格检查

uv run ruff check .

Unit tests

单元测试

uv run pytest tests/unit/ --no-cov -v


**Checklist:**
- [ ] Files exist with complete implementations (no stubs/TODOs)
- [ ] Unit tests pass (isolated behavior verified)
- [ ] Type checking passes (no type errors)
- [ ] Linting passes (code style clean)

**If any fail:** Fix before proceeding to Phase 2

uv run pytest tests/unit/ --no-cov -v


**检查清单：**
- [ ] 文件已存在且实现完整（无存根/TODO）
- [ ] 单元测试通过（已验证孤立行为）
- [ ] 类型检查通过（无类型错误）
- [ ] 代码风格检查通过（代码风格合规）

**如果任何项失败：** 修复后再进入阶段2

Phase 2: Verify Connection (Wiring Exists)

阶段2：验证连接（已接入系统）

2.1 Check Import Statements

2.1 检查导入语句

For a new module

your_module.py

bash

undefined

对于新模块

your_module.py

：

bash

undefined

Find all imports of your module

查找所有导入此模块的语句

grep -r "from.*your_module import|import.your_module" src/ --include=".py" | grep -v test


**Expected:** At least one import in production code (not just tests)

**If empty:** Module is NOT imported → NOT CONNECTED

grep -r "from.*your_module import|import.your_module" src/ --include=".py" | grep -v test


**预期结果：** 至少在生产代码中存在一处导入（不只是测试代码）

**如果无结果：** 模块未被导入 → 未连接

2.2 Check Call-Sites

2.2 检查调用位置

For a new function

your_function

bash

undefined

对于新函数

your_function

：

bash

undefined

Find all call-sites

查找所有调用位置

grep -r "your_function" src/ --include="*.py" | grep -v test | grep -v "def your_function"


**Expected:** At least one call-site in production code

**If empty:** Function is never called → NOT CONNECTED

grep -r "your_function" src/ --include="*.py" | grep -v test | grep -v "def your_function"


**预期结果：** 至少在生产代码中存在一处调用

**如果无结果：** 函数从未被调用 → 未连接

2.3 Check Registration (if applicable)

2.3 检查注册情况（如适用）

For components that require registration:

bash

undefined

对于需要注册的组件：

bash

undefined

LangGraph nodes

LangGraph节点

grep -E "add_node.*your_node|from.*your_module" src/coordination/graph/builder.py

CLI commands

CLI命令

grep -r "add_command|@.*.command|@click.command" src/ | grep your_command

DI container

依赖注入容器

grep -r "container.register|container.provide" src/ | grep YourService

API routes

API路由

grep -r "router.add|@.*.route|@app." src/ | grep your_endpoint


**Expected:** Registration code exists

**If empty:** Component is NOT registered → NOT CONNECTED

**Checklist:**
- [ ] Module imported in at least one production file
- [ ] Functions/classes called in at least one production path
- [ ] (If applicable) Component registered in system
- [ ] Can trace path from entry point to your code

**If any fail:** Wire the code before proceeding to Phase 3

grep -r "router.add|@.*.route|@app." src/ | grep your_endpoint


**预期结果：** 存在注册代码

**如果无结果：** 组件未注册 → 未连接

**检查清单：**
- [ ] 模块至少在一个生产文件中被导入
- [ ] 函数/类至少在一个生产路径中被调用
- [ ] （如适用）组件已在系统中注册
- [ ] 可追踪从入口点到你的代码的路径

**如果任何项失败：** 接入代码后再进入阶段3

Phase 3: Verify Execution (Runtime Proof)

阶段3：验证执行（运行时证据）

3.1 Trigger the Feature

3.1 触发功能

Execute the actual entry point:

bash

undefined

执行实际的入口点：

bash

undefined

Example: CLI command

示例：CLI命令

uv run temet-run -a talky -p "test command"

Example: API endpoint

示例：API端点

curl -X POST http://localhost:8000/api/endpoint -d '{"test": "data"}'

Example: Direct invocation

示例：直接调用

uv run python -c "from myapp.service import MyService; MyService().method()"


**Observe:** Command completes without errors

uv run python -c "from myapp.service import MyService; MyService().method()"


**观察：** 命令无错误完成

3.2 Capture Execution Evidence

3.2 捕获执行证据

Look for evidence that YOUR code executed:

bash

undefined

查找证明你的代码已执行的证据：

bash

undefined

Check logs for your module

检查日志中是否有你的模块信息

grep "your_module|your_function" logs/daemon.log

Check structured logs

检查结构化日志

grep "your_module" logs/*.jsonl | jq .

Check database for expected changes

检查数据库中的预期变更

sqlite3 app.db "SELECT * FROM your_table WHERE created_at > datetime('now', '-1 minute')"


**Expected:** Evidence that your code path was executed

**If no evidence:** Code path was not reached → NOT VERIFIED

sqlite3 app.db "SELECT * FROM your_table WHERE created_at > datetime('now', '-1 minute')"


**预期结果：** 存在代码路径已执行的证据

**如果无证据：** 代码路径未被触发 → 未验证

3.3 Confirm Correct Behavior

3.3 确认行为正确

Verify the outcome matches expectations:

bash

undefined

验证结果符合预期：

bash

undefined

Check state changes

检查状态变更

Example: LangGraph state field populated

示例：LangGraph状态字段已填充

assert result.your_field is not None

Example: File created

示例：文件已创建

ls -la expected_output_file.txt

Example: Database row inserted

示例：数据库行已插入

(query from 3.2)

（来自3.2的查询）


**Expected:** Behavior matches specification

**If incorrect:** Implementation has bugs → NOT VERIFIED

**Checklist:**
- [ ] Feature can be triggered via documented entry point
- [ ] Logs/traces show code execution
- [ ] Expected outcome observed (state change, output, etc.)
- [ ] Can answer all Four Questions

**If any fail:** Debug and fix before claiming "done"


**预期结果：** 行为符合规范

**如果不符合：** 实现存在bug → 未验证

**检查清单：**
- [ ] 可通过文档化的入口点触发功能
- [ ] 日志/追踪信息显示代码已执行
- [ ] 观测到预期结果（状态变更、输出等）
- [ ] 可回答所有四个问题

**如果任何项失败：** 调试并修复后再声称“已完成”

Verification by Artifact Type

按工件类型进行验证

LangGraph Nodes

LangGraph节点

Creation:

Node file exists (e.g.,
```
architecture_nodes.py
```
)
Factory function implemented (e.g.,
```
create_architecture_review_node()
```
)
Routing function implemented (e.g.,
```
should_review_architecture()
```
)
Unit tests pass

Connection:

bash

undefined

创建阶段：

节点文件存在（例如
```
architecture_nodes.py
```
）
工厂函数已实现（例如
```
create_architecture_review_node()
```
）
路由函数已实现（例如
```
should_review_architecture()
```
）
单元测试通过

连接阶段：

bash

undefined

Verify import

验证导入

grep "architecture_nodes" src/temet_run/coordination/graph/builder.py

Expected output:

预期输出：

from .architecture_nodes import create_architecture_review_node, should_review_architecture


- [ ] Imported in `builder.py`
- [ ] Node added to graph: `graph.add_node("your_node", node)`
- [ ] Edges wired: `graph.add_conditional_edges(...)` or `graph.add_edge(...)`

**Verification:**
```bash


- [ ] 在`builder.py`中已导入
- [ ] 节点已添加到图中：`graph.add_node("your_node", node)`
- [ ] 已添加边以接入工作流：`graph.add_conditional_edges(...)` 或 `graph.add_edge(...)`

**验证阶段：**
```bash

Add to test_graph_completeness.py

添加到test_graph_completeness.py

EXPECTED_NODES = [ "your_node_name", # Add this # ... other nodes ]


- [ ] Node in `EXPECTED_NODES` list
- [ ] Integration test passes
- [ ] Coordinator execution shows node in logs
- [ ] State field populated after execution

EXPECTED_NODES = [ "your_node_name", # 添加此项 # ... 其他节点 ]


- [ ] 节点已在`EXPECTED_NODES`列表中
- [ ] 集成测试通过
- [ ] 协调器执行日志中显示该节点
- [ ] 执行后状态字段已填充

CLI Commands

CLI命令

Creation:

Command function exists
Decorated with
```
@click.command()
```
or
```
@app.command()
```
Tests pass

Connection:

bash

undefined

创建阶段：

命令函数存在
已用
```
@click.command()
```
或
```
@app.command()
```
装饰
测试通过

连接阶段：

bash

undefined

Verify registration

验证注册情况

grep -r "add_command|@.*.command" src/your_app/cli/ | grep your_command_name


- [ ] Command registered in CLI group
- [ ] Shows in `--help` output

**Verification:**
```bash

grep -r "add_command|@.*.command" src/your_app/cli/ | grep your_command_name


- [ ] 命令已在CLI组中注册
- [ ] 在`--help`输出中可见

**验证阶段：**
```bash

Test command

测试命令

uv run your-app your-command --help uv run your-app your-command [args]


- [ ] Command appears in `--help`
- [ ] Command executes without errors
- [ ] Expected output observed

uv run your-app your-command --help uv run your-app your-command [args]


- [ ] 命令在`--help`中显示
- [ ] 命令可无错误执行
- [ ] 观测到预期输出

Service Classes (with DI)

服务类（带依赖注入）

Creation:

Service class exists
Methods implemented
Unit tests pass

Connection:

bash

undefined

创建阶段：

服务类存在
方法已实现
单元测试通过

连接阶段：

bash

undefined

Verify DI registration

验证依赖注入注册

grep -r "container.register|register_singleton|provide" src/ | grep YourServiceName


- [ ] Service registered in container
- [ ] Dependencies injected correctly

**Verification:**
```bash

grep -r "container.register|register_singleton|provide" src/ | grep YourServiceName


- [ ] 服务已在容器中注册
- [ ] 依赖项已正确注入

**验证阶段：**
```bash

Test injection

测试注入

uv run python -c " from your_app.container import container service = container.resolve('YourService') service.method() "


- [ ] Service can be resolved from container
- [ ] Method executes correctly
- [ ] Dependencies are provided

uv run python -c " from your_app.container import container service = container.resolve('YourService') service.method() "


- [ ] 可从容器中解析出服务
- [ ] 方法可正确执行
- [ ] 依赖项已提供

API Endpoints

API端点

Creation:

Endpoint function exists
Route handler implemented
Tests pass

Connection:

bash

undefined

创建阶段：

端点函数存在
路由处理器已实现
测试通过

连接阶段：

bash

undefined

Verify route registration

验证路由注册

grep -r "router.add|@.*.route|@app." src/ | grep your_endpoint


- [ ] Route added to router
- [ ] Endpoint shows in OpenAPI docs (if applicable)

**Verification:**
```bash

grep -r "router.add|@.*.route|@app." src/ | grep your_endpoint


- [ ] 路由已添加到路由器
- [ ] 端点在OpenAPI文档中可见（如适用）

**验证阶段：**
```bash

Test endpoint

测试端点

curl -X POST http://localhost:8000/api/your-endpoint -d '{"test": "data"}'


- [ ] Endpoint responds (not 404)
- [ ] Expected status code (200, 201, etc.)
- [ ] Response body correct

curl -X POST http://localhost:8000/api/your-endpoint -d '{"test": "data"}'


- [ ] 端点可响应（不是404）
- [ ] 返回预期状态码（200、201等）
- [ ] 响应体正确

Common Failure Patterns

常见失败模式

Pattern 1: Created But Never Imported

模式1：已创建但从未被导入

Symptom: File exists, tests pass, but nothing uses it

Detection:

bash

grep -r "from.*your_module import" src/ --include="*.py" | grep -v test

症状： 文件存在，测试通过，但无任何代码使用它

检测方式：

bash

grep -r "from.*your_module import" src/ --include="*.py" | grep -v test

Returns: (empty)

返回：（无结果）


**Fix:** Add import where the module should be used


**修复：** 在需要使用该模块的位置添加导入

Pattern 2: Imported But Never Called

模式2：已导入但从未被调用

Symptom: Import exists, but functions never invoked

Detection:

bash

grep -r "your_function_name" src/ --include="*.py" | grep -v test | grep -v "def "

症状： 导入存在，但函数从未被调用

检测方式：

bash

grep -r "your_function_name" src/ --include="*.py" | grep -v test | grep -v "def "

Returns: (empty - only the definition exists)

返回：（无结果 - 仅存在函数定义）


**Fix:** Add call-site where the function should be used


**修复：** 在需要使用该函数的位置添加调用

Pattern 3: Registered But Wrong Configuration

模式3：已注册但配置错误

Symptom: Component registered, but with wrong parameters/order

Detection: Integration tests fail, runtime errors

Fix: Review registration code, compare with working examples

症状： 组件已注册，但参数/顺序错误

检测方式： 集成测试失败，运行时出错

修复： 检查注册代码，与可用示例对比

Pattern 4: Unit Tests Pass, Integration Fails

模式4：单元测试通过，集成测试失败

Symptom: Isolated tests work, but feature fails in real system

Detection: Integration tests fail, or manual testing shows errors

Fix: Add integration tests that exercise real dependencies

症状： 孤立测试通过，但在真实系统中功能失败

检测方式： 集成测试失败，或手动测试显示错误

修复： 添加集成测试以验证真实依赖

Pattern 5: Code Reachable But Conditional Never Triggers

模式5：代码可访问但条件从未触发

Symptom: Code is wired, but conditional logic prevents execution

Detection: Code never appears in logs despite feature being triggered

Fix: Review conditional logic, adjust trigger conditions

症状： 代码已接入系统，但条件逻辑阻止执行

检测方式： 触发功能后，日志中从未出现该代码的记录

修复： 检查条件逻辑，调整触发条件

Supporting Files

支持文件

References

参考文档

```
references/ccv-principle.md
```
- Deep dive into Creation-Connection-Verification
```
references/four-questions-framework.md
```
- Detailed explanation of the Four Questions
```
references/adr-013-case-study.md
```
- Real-world failure that motivated this skill

```
references/ccv-principle.md
```
- 创建-连接-验证原则的深度解析
```
references/four-questions-framework.md
```
- 四个问题框架的详细说明
```
references/adr-013-case-study.md
```
- 促成此技能诞生的真实故障案例

Examples

示例

```
examples/langgraph-node-verification.md
```
- Complete LangGraph node verification example
```
examples/cli-command-verification.md
```
- CLI command verification walkthrough
```
examples/service-di-verification.md
```
- Service with DI verification example

```
examples/langgraph-node-verification.md
```
- 完整的LangGraph节点验证示例
```
examples/cli-command-verification.md
```
- CLI命令验证分步指南
```
examples/service-di-verification.md
```
- 带依赖注入的服务验证示例

Scripts

脚本

```
scripts/verify_integration.sh
```
- Automated orphan detection script
```
scripts/check_imports.sh
```
- Check if module is imported
```
scripts/check_callsites.sh
```
- Check if functions are called

```
scripts/verify_integration.sh
```
- 自动化孤立代码检测脚本
```
scripts/check_imports.sh
```
- 检查模块是否已导入
```
scripts/check_callsites.sh
```
- 检查函数是否已被调用

Templates

模板

```
templates/verification-checklist.md
```
- Copy-paste checklist for feature verification
```
templates/integration-test-template.py
```
- Template for integration tests

```
templates/verification-checklist.md
```
- 功能验证可复制粘贴清单
```
templates/integration-test-template.py
```
- 集成测试模板

Expected Outcomes

预期结果

Successful Verification

验证成功

✅ Implementation Verification Complete

Feature: ArchitectureReview Node
Location: src/temet_run/coordination/graph/architecture_nodes.py

Phase 1: CREATION ✅
  - File exists (175 lines)
  - Unit tests pass (24/24)
  - Type checking clean
  - Linting clean

Phase 2: CONNECTION ✅
  - Imported in: builder.py line 12
  - Registered: graph.add_node("architecture_review", node)
  - Edges: Conditional edge from "query_claude"
  - Evidence:
    $ grep "architecture_nodes" src/coordination/graph/builder.py
    from .architecture_nodes import create_architecture_review_node

Phase 3: VERIFICATION ✅
  - Integration test: EXPECTED_NODES includes "architecture_review"
  - Execution proof:
    [2025-12-07 10:30:45] INFO architecture_review_triggered
    [2025-12-07 10:30:46] INFO architecture_review_complete status=approved
  - Outcome proof: state.architecture_review = ArchitectureReviewResult(...)

Four Questions Test ✅
  1. Trigger: uv run temet-run -a talky -p "Write code"
  2. Connection: builder.py line 12 (import), line 146 (add_node)
  3. Execution: Logs above show node executed
  4. Outcome: state.architecture_review contains approval data

✅ IMPLEMENTATION IS COMPLETE

✅ 实现验证完成

功能：ArchitectureReview Node
位置：src/temet_run/coordination/graph/architecture_nodes.py

阶段1：创建 ✅
  - 文件存在（175行）
  - 单元测试通过（24/24）
  - 类型检查合规
  - 代码风格检查合规

阶段2：连接 ✅
  - 导入位置：builder.py第12行
  - 注册情况：graph.add_node("architecture_review", node)
  - 边配置：从"query_claude"添加条件边
  - 证据：
    $ grep "architecture_nodes" src/coordination/graph/builder.py
    from .architecture_nodes import create_architecture_review_node

阶段3：验证 ✅
  - 集成测试：EXPECTED_NODES包含"architecture_review"
  - 执行证据：
    [2025-12-07 10:30:45] INFO architecture_review_triggered
    [2025-12-07 10:30:46] INFO architecture_review_complete status=approved
  - 结果证据：state.architecture_review = ArchitectureReviewResult(...)

四个问题测试 ✅
  1. 触发方式：uv run temet-run -a talky -p "Write code"
  2. 连接位置：builder.py第12行（导入）、第146行（添加节点）
  3. 执行证据：上述日志显示节点已执行
  4. 结果证据：state.architecture_review包含审批数据

✅ 实现已完成

Verification Failure

验证失败

❌ Implementation Verification Failed

Feature: ArchitectureReview Node
Location: src/temet_run/coordination/graph/architecture_nodes.py

Phase 1: CREATION ✅
  - File exists (175 lines)
  - Unit tests pass (24/24)
  - Type checking clean
  - Linting clean

Phase 2: CONNECTION ❌
  - Imported in: NOT FOUND
  - Evidence:
    $ grep "architecture_nodes" src/coordination/graph/builder.py
    (empty - no imports found)

CRITICAL FAILURE: Module is not imported in builder.py

❌ IMPLEMENTATION IS INCOMPLETE

Required Actions:
1. Add import in builder.py: from .architecture_nodes import create_architecture_review_node
2. Register node: graph.add_node("architecture_review", review_node)
3. Add edges to wire into workflow
4. Re-run verification after fixes

DO NOT claim this feature is "done" until verification passes.

❌ 实现验证失败

功能：ArchitectureReview Node
位置：src/temet_run/coordination/graph/architecture_nodes.py

阶段1：创建 ✅
  - 文件存在（175行）
  - 单元测试通过（24/24）
  - 类型检查合规
  - 代码风格检查合规

阶段2：连接 ❌
  - 导入位置：未找到
  - 证据：
    $ grep "architecture_nodes" src/coordination/graph/builder.py
    （无结果 - 未找到导入语句）

严重故障：模块未在builder.py中导入

❌ 实现未完成

需执行的操作：
1. 在builder.py中添加导入：from .architecture_nodes import create_architecture_review_node
2. 注册节点：graph.add_node("architecture_review", review_node)
3. 添加边以接入工作流
4. 修复后重新运行验证

在验证通过前，请勿声称此功能“已完成”。

Requirements

要求

Tools Required

所需工具

Read (to examine source files)
Grep (to search for imports/calls)
Bash (to run verification commands)

读取权限（用于检查源文件）
Grep（用于搜索导入/调用情况）
Bash（用于运行验证命令）

Knowledge Required

所需知识

Understanding of the project's architecture
Knowledge of where entry points are (main.py, builder.py, etc.)
Familiarity with import paths and module structure

了解项目架构
知道入口点位置（main.py、builder.py等）
熟悉导入路径和模块结构

Environment Required

所需环境

Working directory is project root
Source code in
```
src/
```
directory
Tests in
```
tests/
```
directory

工作目录为项目根目录
源代码位于
```
src/
```
目录
测试代码位于
```
tests/
```
目录

Red Flags to Avoid

需避免的警示信号

Do Not

请勿

❌ Claim "feature complete" without running this verification
❌ Skip Phase 2 (connection) verification
❌ Skip Phase 3 (runtime) verification
❌ Accept "tests pass" as proof of integration
❌ Move ADRs to
```
completed/
```
without this verification
❌ Self-approve without answering Four Questions
❌ Assume code is integrated just because it compiles
❌ Trust unit tests alone (they can hide orphaned code)

❌ 未运行此验证就声称“功能已完成”
❌ 跳过阶段2（连接）验证
❌ 跳过阶段3（运行时）验证
❌ 将“测试通过”作为集成的证明
❌ 未进行此验证就将ADR移至
```
completed/
```
❌ 未回答四个问题就自我批准
❌ 仅因代码可编译就假设已集成
❌ 仅依赖单元测试（它们可能掩盖孤立代码）

Do

请

✅ Run all three phases of verification
✅ Paste actual command output as evidence
✅ Answer all Four Questions before claiming "done"
✅ Add integration tests for new components
✅ Update
```
EXPECTED_NODES
```
or equivalent tracking lists
✅ Show execution logs as proof
✅ Verify correct behavior, not just "no errors"
✅ Document evidence in task/ADR completion notes

✅ 运行所有三个阶段的验证
✅ 粘贴实际命令输出作为证据
✅ 在声称“已完成”前回答所有四个问题
✅ 为新组件添加集成测试
✅ 更新
```
EXPECTED_NODES
```
或类似的跟踪列表
✅ 出示执行日志作为证据
✅ 验证行为是否正确，而不只是“无错误”
✅ 在任务/ADR完成说明中记录证据

Notes

说明

This skill was created in response to ADR-013 failure (2025-12-07)
The failure: 313 lines of code, 46 passing tests, but code never integrated
This skill prevents that exact failure mode from recurring
Integrate this skill with
```
util-manage-todo
```
(three-phase pattern)
Integrate with
```
create-adr-spike
```
(Phase 6: Integration Verification)
Integrate with
```
quality-run-quality-gates
```
(add as Gate 6)

Remember: Code is not "done" when it compiles and tests pass. Code is "done" when it executes at runtime and produces correct outcomes.

此技能是为应对ADR-013故障（2025-12-07）而创建
故障详情：313行代码，46个测试通过，但代码从未集成
此技能可防止完全相同的故障模式再次发生
可与
```
util-manage-todo
```
集成（三阶段模式）
可与
```
create-adr-spike
```
集成（阶段6：集成验证）
可与
```
quality-run-quality-gates
```
集成（添加为第6个关卡）

切记： 代码并非“已完成”当它可编译且测试通过时。只有当它能在运行时执行并产生正确结果时，才是“已完成”。

quality-verify-implementation-complete

Original

Translation

Verify Implementation Complete

验证实现完成度

Quick Start

快速开始

1. Check if your new module is imported

1. 检查新模块是否已导入

2. Check if your functions are called

2. 检查函数是否被调用

3. Run integration verification

3. 运行集成验证

4. Answer the Four Questions (see below)

4. 回答四个问题（见下文）

Table of Contents

目录

When to Use This Skill

何时使用此技能

Explicit Triggers

显式触发场景

Implicit Triggers

隐式触发场景

Debugging Triggers

调试触发场景

What This Skill Does

此技能的作用

The CCV Principle

CCV原则

The Formula

公式

The Three Phases

三个阶段

Why All Three Are Required

为何三个阶段缺一不可

The Four Questions Test

四个问题测试

Question 1: How do I trigger this?

问题1：如何触发此功能？

Question 2: What connects it to the system?

问题2：它与系统的连接点在哪里？

Question 3: What evidence proves it runs?

问题3：有什么证据证明它已执行？

Question 4: What shows it works correctly?

问题4：有什么能证明它工作正常？

Step-by-Step Verification Process

分步验证流程

Phase 1: Verify Creation (Artifacts Exist)

阶段1：验证创建（工件存在）

Type checking

类型检查

Linting

代码风格检查

Unit tests

单元测试

Phase 2: Verify Connection (Wiring Exists)

阶段2：验证连接（已接入系统）

2.1 Check Import Statements

2.1 检查导入语句

Find all imports of your module

查找所有导入此模块的语句

2.2 Check Call-Sites

2.2 检查调用位置

Find all call-sites

查找所有调用位置

2.3 Check Registration (if applicable)

2.3 检查注册情况（如适用）

LangGraph nodes

LangGraph节点

CLI commands

CLI命令

DI container

依赖注入容器

API routes

API路由

Phase 3: Verify Execution (Runtime Proof)

阶段3：验证执行（运行时证据）

3.1 Trigger the Feature

3.1 触发功能

Example: CLI command