From 757633773caad71e50b2607cadb7e82fc9d51618 Mon Sep 17 00:00:00 2001
From: SummerOneTwo <89140025+SummerOneTwo@users.noreply.github.com>
Date: Wed, 29 Apr 2026 03:16:32 +0800
Subject: [PATCH 1/4] fix mcp test generation stability and recovery

Made-with: Cursor
---
 CLAUDE.md                             |   8 +-
 README.md                             |  10 +-
 agents/autocode-workflow.md           |   4 +-
 pyproject.toml                        |   1 +
 scripts/workflow_guard.py             |   2 +
 skills/autocode-workflow/SKILL.md     |   4 +-
 src/autocode_mcp/prompts/__init__.py  |   2 +
 src/autocode_mcp/server.py            |  20 +-
 src/autocode_mcp/tools/generator.py   |  50 ++++
 src/autocode_mcp/tools/problem.py     | 377 +++++++++++++++++++++++-
 src/autocode_mcp/tools/test_verify.py |  80 +++++-
 src/autocode_mcp/utils/compiler.py    |  35 ++-
 src/autocode_mcp/utils/win_job.py     |   6 +
 tests/test_compiler.py                |  38 +++
 tests/test_tools/test_generator.py    |  31 ++
 tests/test_tools/test_problem.py      | 268 ++++++++++++++++-
 uv.lock                               | 399 ++++++++++++++++++++++++++
 17 files changed, 1297 insertions(+), 38 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index accd1ee..1b8ea67 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -88,9 +88,9 @@ AutoCode/
 ├── statements/         # 题面
 │   └── README.md
 └── tests/              # 生成的测试数据
-    ├── 01.in
-    ├── 01.ans
-    └── ...
+ ├── 01.in
+ ├── 01.ans / 01.out（由 answer_ext 控制）
+ └── ...
 ```
 
 ## 出题工作流程
@@ -102,7 +102,7 @@ AutoCode/
 5. 构建生成器 (`generator_build`)
 6. 运行压力测试 (`stress_test_run`, completed_rounds == total_rounds)
 7. 按需构建检查器 (`checker_build`, accuracy >= 0.9)
-8. 生成测试数据（`problem_generate_tests`, generated_test_count > 0，且最终 extreme/tle 至少占一半；候选不足时尽量满足）
+8. 生成测试数据（`problem_generate_tests`, generated_test_count > 0，支持 `answer_ext`；最终 extreme/tle 至少占一半；候选不足时尽量满足；长任务中断可 `resume=true` 续跑）
 9. 验证测试数据 (`problem_verify_tests`, passed)
 10. 打包 Polygon (`problem_pack_polygon`)
 
diff --git a/README.md b/README.md
index bb4a7ea..7e90460 100644
--- a/README.md
+++ b/README.md
@@ -246,7 +246,7 @@ AutoCode 提供 15 个原子工具，分为 7 组。所有工具返回统一格
 | 工具 | 描述 | 关键参数 |
 |------|------|----------|
 | `problem_create` | 初始化题目目录 | `problem_dir`, `problem_name` |
-| `problem_generate_tests` | 生成最终测试数据（最终数据集中 extreme/tle 至少占一半，候选不足时尽量满足） | `problem_dir`, `test_count` |
+| `problem_generate_tests` | 生成最终测试数据（最终数据集中 extreme/tle 至少占一半，候选不足时尽量满足） | `problem_dir`, `test_count`, `answer_ext`, `resume`, `hard_timeout_seconds` |
 | `problem_verify_tests` | 验证测试数据质量（含 extreme/tle 占比硬校验） | `problem_dir`, `tests_dir`, `verify_types` |
 | `problem_pack_polygon` | 打包为 Polygon 格式 | `problem_dir`, `time_limit`, `memory_limit` |
 
@@ -375,11 +375,13 @@ All 1000 rounds passed
 ```python
 problem_generate_tests(
     problem_dir="problems/ab",
-    test_count=50
+    test_count=50,
+    answer_ext=".out",      # 可选，默认 .ans
+    hard_timeout_seconds=600
 )
 ```
 
-说明：最终写入的测试中，`extreme`（type=3）与 `tle`（type=4）合计不少于一半；若候选里极限类不足，则会在可用候选范围内尽量满足并返回对应统计字段。
+说明：最终写入的测试中，`extreme`（type=3）与 `tle`（type=4）合计不少于一半；若候选里极限类不足，则会在可用候选范围内尽量满足并返回对应统计字段。若长任务被中断，可使用 `resume=true` 从 checkpoint 续跑。
 
 ### 步骤 7：打包为 Polygon 格式
 
@@ -499,7 +501,7 @@ problems/your-problem/
 │   └── README.md       # 题目描述
 ├── tests/
 │   ├── 01.in           # 测试输入
-│   ├── 01.ans          # 期望输出
+│   ├── 01.ans/.out     # 期望输出（由 answer_ext 控制）
 │   └── ...
 └── problem.xml         # Polygon 配置
 ```
diff --git a/agents/autocode-workflow.md b/agents/autocode-workflow.md
index 5a78c20..dc2d2e8 100644
--- a/agents/autocode-workflow.md
+++ b/agents/autocode-workflow.md
@@ -25,6 +25,8 @@ Always work through this sequence unless the task is explicitly outside problem
 
 When the user asks for a later step directly, explain which prerequisite step is missing and complete the missing work first.
 
-When running `problem_generate_tests`, enforce test quality: final test data should contain at least half limit-oriented cases (`type=3` extreme + `type=4` tle) when candidate availability allows.
+When running `problem_generate_tests`, enforce test quality: final test data should contain at least half limit-oriented cases (`type=3` extreme + `type=4` tle) when candidate availability allows. Also enforce that generator logic for type=3 and type=4 is semantically different (type=4 should include targeted worst-case patterns, not only max-parameter scaling).
+
+For long-running `problem_generate_tests`, warn that new user messages can interrupt MCP execution. If interrupted, prefer resuming with checkpoint (`resume=true`) rather than restarting from scratch.
 
 Treat hook feedback as authoritative. If a hook denies a tool call, fix the workflow gap instead of retrying the same call.
diff --git a/pyproject.toml b/pyproject.toml
index 62dafa0..4be9fa2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -80,6 +80,7 @@ exclude_lines = [
 
 [dependency-groups]
 dev = [
+    "twine>=6.2.0",
     "types-psutil>=7.2.2.20260402",
     "types-pywin32>=311.0.0.20260402",
     "types-pyyaml>=6.0.12.20250915",
diff --git a/scripts/workflow_guard.py b/scripts/workflow_guard.py
index 982b563..c97604e 100644
--- a/scripts/workflow_guard.py
+++ b/scripts/workflow_guard.py
@@ -272,6 +272,8 @@ def session_start() -> int:
         "problem_validate(validation_passed) -> "
         "problem_generate_tests(generated_test_count > 0, and prefer >=50% type3/type4 in final tests when candidates are sufficient) -> "
         "problem_verify_tests(passed) -> problem_pack_polygon. "
+        "When running long problem_generate_tests tasks, avoid sending new chat messages because that can interrupt MCP calls; if interrupted, resume with checkpoint state (resume=true). "
+        "Generator quality gate: ensure type=3 and type=4 branches are semantically different, and type=4 includes targeted worst-case patterns rather than only max parameters. "
         "If a hook blocks a step, complete the missing prerequisite instead of retrying blindly."
     )
     print(
diff --git a/skills/autocode-workflow/SKILL.md b/skills/autocode-workflow/SKILL.md
index 1ae7e86..7816854 100644
--- a/skills/autocode-workflow/SKILL.md
+++ b/skills/autocode-workflow/SKILL.md
@@ -233,9 +233,10 @@ CRITICAL: Must pass validation before generating final tests
 Tool: problem_generate_tests
 Required: problem_dir
 Recommended: test_count=50, enable_dedup=true, enable_validator_filter=true
-Output: tests/01.in ~ tests/50.in + corresponding .ans files
+Output: tests/01.in ~ tests/50.in + corresponding answer files (`.ans` by default, or configured `answer_ext` such as `.out`)
 Verify: Check generated_tests count matches test_count
 Quality Gate: In final tests, type 3/4 (extreme + tle) should be >= ceil(test_count/2) when candidates are sufficient
+Long-running note: sending new user messages may interrupt MCP execution; prefer waiting, or resume with `resume=true` if interrupted.
 ```
 
 ### Phase 9: Packaging
@@ -337,6 +338,7 @@ Before considering the problem complete:
 - [ ] Sample files validated (problem_validate passed)
 - [ ] Final test data generated (50+ tests)
 - [ ] Final test data has at least 50% extreme/tle cases when candidate pool allows
+- [ ] type=3/type=4 generation logic is semantically different (not just max-parameter duplication)
 - [ ] Polygon package created
 
 ## Example Complete Workflow
diff --git a/src/autocode_mcp/prompts/__init__.py b/src/autocode_mcp/prompts/__init__.py
index 1f697fd..da0d704 100644
--- a/src/autocode_mcp/prompts/__init__.py
+++ b/src/autocode_mcp/prompts/__init__.py
@@ -65,6 +65,7 @@
 - 先保证最终测试中至少一半是 extreme/tle（type=3/4，候选不足时尽量满足）
 - 再平衡分布
 - 采样
+- 长任务期间避免发送新消息（可能中断 MCP 调用）；若中断，优先使用 resume/checkpoint 续跑
 
 ## 质量指标
 - Consistency > 90%
@@ -124,6 +125,7 @@
 - type=2 (random): 随机数据
 - type=3 (extreme): 极端数据（溢出、精度、hash碰撞）
 - type=4 (tle): TLE 诱导数据
+- 要求 type=3 与 type=4 分支有实质差异，type=4 应包含针对性卡法，不应仅靠 n_max/t_max 拉满
 
 ### 代码模板
 ```cpp
diff --git a/src/autocode_mcp/server.py b/src/autocode_mcp/server.py
index 6cadd2d..ad513db 100644
--- a/src/autocode_mcp/server.py
+++ b/src/autocode_mcp/server.py
@@ -32,7 +32,12 @@
 from .tools.file_ops import FileReadTool, FileSaveTool
 from .tools.generator import GeneratorBuildTool, GeneratorRunTool
 from .tools.interactor import InteractorBuildTool
-from .tools.problem import ProblemCreateTool, ProblemGenerateTestsTool, ProblemPackPolygonTool
+from .tools.problem import (
+    ProblemCleanupProcessesTool,
+    ProblemCreateTool,
+    ProblemGenerateTestsTool,
+    ProblemPackPolygonTool,
+)
 from .tools.solution import SolutionBuildTool, SolutionRunTool
 from .tools.stress_test import StressTestRunTool
 from .tools.test_verify import ProblemVerifyTestsTool
@@ -68,6 +73,7 @@ def register_all_tools() -> None:
     # Problem 工具组
     register_tool(ProblemCreateTool())
     register_tool(ProblemGenerateTestsTool())
+    register_tool(ProblemCleanupProcessesTool())
     register_tool(ProblemVerifyTestsTool())
     register_tool(ProblemPackPolygonTool())
     register_tool(ProblemValidateTool())
@@ -118,6 +124,18 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> CallToolResult:
             structuredContent=result_dict,
             isError=not result.success,
         )
+    except asyncio.CancelledError:
+        cancel_result = ToolResult.fail(
+            "Tool call interrupted by cancellation",
+            interrupted=True,
+            resume_hint="Retry with resume=true if tool supports checkpoints",
+        )
+        cancel_dict = cancel_result.to_dict()
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(cancel_dict, ensure_ascii=False))],
+            structuredContent=cancel_dict,
+            isError=True,
+        )
     except Exception as e:
         error_result = ToolResult.fail(str(e))
         error_dict = error_result.to_dict()
diff --git a/src/autocode_mcp/tools/generator.py b/src/autocode_mcp/tools/generator.py
index a487523..db2dc59 100644
--- a/src/autocode_mcp/tools/generator.py
+++ b/src/autocode_mcp/tools/generator.py
@@ -8,6 +8,7 @@
 
 import hashlib
 import os
+import re
 
 from ..utils.compiler import run_binary, run_binary_with_args
 from ..utils.platform import get_exe_extension
@@ -58,6 +59,16 @@ def input_schema(self) -> dict:
                     "description": "编译器名称",
                     "default": "g++",
                 },
+                "enable_semantic_check": {
+                    "type": "boolean",
+                    "description": "是否启用 type=3/type=4 语义静态检查",
+                    "default": True,
+                },
+                "strict_semantic_check": {
+                    "type": "boolean",
+                    "description": "语义静态检查不通过时是否直接失败",
+                    "default": False,
+                },
             },
             "required": ["problem_dir"],
             "anyOf": [
@@ -72,6 +83,8 @@ async def execute(
         code: str | None = None,
         source_path: str | None = None,
         compiler: str = "g++",
+        enable_semantic_check: bool = True,
+        strict_semantic_check: bool = False,
     ) -> ToolResult:
         """执行 Generator 构建。"""
         resolved, err = resolve_source(problem_dir, code, source_path)
@@ -107,15 +120,52 @@ async def execute(
 
         binary_size = os.path.getsize(binary_path) if os.path.exists(binary_path) else 0
 
+        semantic_check = self._check_type34_semantics(resolved.code) if enable_semantic_check else {"enabled": False}
+        if (
+            enable_semantic_check
+            and strict_semantic_check
+            and not semantic_check.get("passed", True)
+        ):
+            return ToolResult.fail(
+                "Generator semantic check failed: type=3/type=4 lack substantial difference",
+                semantic_check=semantic_check,
+            )
+
         return ToolResult.ok(
             source_path=compile_source,
             canonical_path=canonical_path,
             binary_path=binary_path,
             binary_size=binary_size,
             compile_log=compile_result.stderr,
+            semantic_check=semantic_check,
             message="Generator built successfully",
         )
 
+    def _check_type34_semantics(self, code: str) -> dict:
+        has_type3 = bool(re.search(r"type\s*==\s*3", code))
+        has_type4 = bool(re.search(r"type\s*==\s*4", code))
+        if not has_type3 or not has_type4:
+            return {
+                "enabled": True,
+                "passed": False,
+                "reason": "generator lacks explicit type==3/type==4 branches",
+                "hint": "需要给 type=3/type=4 设计不同逻辑，避免仅靠参数放大",
+            }
+
+        type3_blocks = re.findall(r"type\s*==\s*3[\s\S]{0,240}", code)
+        type4_blocks = re.findall(r"type\s*==\s*4[\s\S]{0,240}", code)
+        norm3 = " ".join(type3_blocks).replace(" ", "")
+        norm4 = " ".join(type4_blocks).replace(" ", "")
+        output_lines = [line.strip() for line in code.splitlines() if "cout" in line or "printf" in line]
+        duplicate_outputs = len(set(output_lines)) <= 1 and len(output_lines) > 0
+        similar = norm3 == norm4 or (norm3 and norm4 and abs(len(norm3) - len(norm4)) < 10) or duplicate_outputs
+        return {
+            "enabled": True,
+            "passed": not similar,
+            "reason": "" if not similar else "type=3/type=4 branch snippets are too similar",
+            "hint": "为 type=4 增加针对性卡法，而不仅是 n_max/t_max 取最大值",
+        }
+
 
 class GeneratorRunTool(Tool):
     """运行多策略数据生成器。"""
diff --git a/src/autocode_mcp/tools/problem.py b/src/autocode_mcp/tools/problem.py
index d6b1e38..f928779 100644
--- a/src/autocode_mcp/tools/problem.py
+++ b/src/autocode_mcp/tools/problem.py
@@ -4,10 +4,12 @@
 
 from __future__ import annotations
 
+import asyncio
 import hashlib
 import json
 import os
 import shutil
+import time
 from dataclasses import dataclass
 
 from ..utils.compiler import run_binary, run_binary_with_args
@@ -28,6 +30,7 @@ class CandidateTest:
 # 最终测试集中「极限类」占比下限：至少一半来自 generator type 3/4（extreme + TLE 压力）
 _LIMIT_STRATEGY_TYPES = frozenset({"3", "4"})
 _TEST_MANIFEST_FILENAME = ".autocode_tests_manifest.json"
+_GENERATE_STATE_FILENAME = ".autocode_generate_state.json"
 
 
 class ProblemCreateTool(Tool):
@@ -238,6 +241,25 @@ def input_schema(self) -> dict:
                     "description": "超额采样比例（生成候选数据 = test_count * ratio）",
                     "default": 1.5,
                 },
+                "answer_ext": {
+                    "type": "string",
+                    "description": "答案文件后缀，默认 .ans，可配置为 .out",
+                    "default": ".ans",
+                },
+                "resume": {
+                    "type": "boolean",
+                    "description": "是否尝试从状态文件恢复中断任务",
+                    "default": False,
+                },
+                "hard_timeout_seconds": {
+                    "type": "integer",
+                    "description": "工具级硬超时（秒），超时后保存状态并返回失败",
+                },
+                "checkpoint_every": {
+                    "type": "integer",
+                    "description": "每生成多少候选写一次 checkpoint，默认 10",
+                    "default": 10,
+                },
             },
             "required": ["problem_dir"],
         }
@@ -255,6 +277,10 @@ async def execute(
         enable_validator_filter: bool = True,
         enable_balance: bool = True,
         oversample_ratio: float = 1.5,
+        answer_ext: str = ".ans",
+        resume: bool = False,
+        hard_timeout_seconds: int | None = None,
+        checkpoint_every: int = 10,
     ) -> ToolResult:
         """执行测试数据生成。
 
@@ -319,6 +345,11 @@ async def execute(
 
         exe_ext = get_exe_extension()
         effective_sol_name = sol_name or "sol"
+        normalized_answer_ext, answer_ext_error = self._normalize_answer_ext(answer_ext)
+        if answer_ext_error:
+            return answer_ext_error
+        assert normalized_answer_ext is not None
+        checkpoint_every = max(1, checkpoint_every)
 
         # 检查必要文件
         gen_exe = os.path.join(problem_dir, "files", f"gen{exe_ext}")
@@ -346,10 +377,8 @@ async def execute(
         # Validator 是否可用
         validator_available = enable_validator_filter and os.path.exists(val_exe)
 
-        # 创建/清空 tests 目录。只移除旧的测试数据，避免误删用户源码或其他文件。
-        clear_error = self._clear_generated_tests(tests_dir)
-        if clear_error:
-            return clear_error
+        state_path = os.path.join(tests_dir, _GENERATE_STATE_FILENAME)
+        start_ts = time.time()
 
         # 获取测试配置
         if test_configs:
@@ -376,8 +405,63 @@ async def execute(
         signatures: set[str] = set()  # 用于去重
         errors: list[tuple[int, str]] = []
         seed = 1
+        progress_snapshot = {
+            "phase": "initializing",
+            "candidates_generated": 0,
+            "target_candidates": candidate_count,
+            "generated_tests": 0,
+            "test_count": test_count,
+            "state_path": state_path,
+        }
+        active_pids: set[int] = set()
+
+        if resume:
+            restored = self._load_state(state_path)
+            if restored:
+                seed = int(restored.get("next_seed", 1))
+                candidates = self._restore_candidates(restored.get("candidates", []))
+                signatures = {c.signature for c in candidates}
+                errors = [(int(e.get("seed", 0)), str(e.get("error", ""))) for e in restored.get("errors", []) if isinstance(e, dict)]
+                raw_active_pids = restored.get("active_pids", [])
+                if isinstance(raw_active_pids, list):
+                    active_pids = {int(pid) for pid in raw_active_pids if isinstance(pid, int)}
+                progress_snapshot["phase"] = str(restored.get("phase", "resumed"))
+                progress_snapshot["candidates_generated"] = len(candidates)
+            else:
+                # resume=true 但状态文件不存在/损坏时，回退到 fresh run，
+                # 避免与旧测试文件混合导致 manifest 覆盖不完整。
+                clear_error = self._clear_generated_tests(tests_dir, normalized_answer_ext)
+                if clear_error:
+                    return clear_error
+                progress_snapshot["phase"] = "resume_fallback_fresh"
+                progress_snapshot["resume_fallback"] = True
+        else:
+            # 创建/清空 tests 目录。只移除旧的测试数据，避免误删用户源码或其他文件。
+            clear_error = self._clear_generated_tests(tests_dir, normalized_answer_ext)
+            if clear_error:
+                return clear_error
 
         while len(candidates) < candidate_count and seed < candidate_count * 10:
+            elapsed = time.time() - start_ts
+            if hard_timeout_seconds and elapsed >= hard_timeout_seconds:
+                self._save_state(
+                    state_path,
+                    phase="timed_out",
+                    next_seed=seed,
+                    candidates=candidates,
+                    errors=errors,
+                    answer_ext=normalized_answer_ext,
+                    active_pids=active_pids,
+                    message="Hard timeout reached",
+                )
+                return ToolResult.fail(
+                    f"Generation timed out after {hard_timeout_seconds}s",
+                    generated_tests=[],
+                    errors=errors,
+                    sol_name=effective_sol_name,
+                    progress_snapshot=progress_snapshot,
+                    resume_hint="Set resume=true to continue from checkpoint",
+                )
             # 循环使用配置
             cfg_idx = (seed - 1) % len(test_configs_list)
             test_cfg = test_configs_list[cfg_idx]
@@ -394,7 +478,12 @@ async def execute(
 
             try:
                 # 生成输入
-                gen_result = await run_binary_with_args(gen_exe, cmd_args, timeout=timeout)
+                gen_result = await self._run_with_retry(
+                    gen_exe,
+                    cmd_args,
+                    timeout=timeout,
+                    active_pids=active_pids,
+                )
                 if gen_result.timed_out or not gen_result.stdout.strip():
                     errors.append((seed, f"Generator failed: {gen_result.stderr}"))
                     seed += 1
@@ -436,12 +525,37 @@ async def execute(
                     )
                 )
 
+            except asyncio.CancelledError:
+                self._save_state(
+                    state_path,
+                    phase="cancelled",
+                    next_seed=seed,
+                    candidates=candidates,
+                    errors=errors,
+                    answer_ext=normalized_answer_ext,
+                    active_pids=active_pids,
+                    message="Cancelled by upstream request",
+                )
+                raise
             except Exception as e:
                 errors.append((seed, str(e)))
 
+            progress_snapshot["phase"] = "candidate_generation"
+            progress_snapshot["candidates_generated"] = len(candidates)
+            if len(candidates) % checkpoint_every == 0:
+                self._save_state(
+                    state_path,
+                    phase="candidate_generation",
+                    next_seed=seed + 1,
+                    candidates=candidates,
+                    errors=errors,
+                    answer_ext=normalized_answer_ext,
+                    active_pids=active_pids,
+                )
             seed += 1
 
         # 极限占比 + 平衡/确定性采样
+        progress_snapshot["phase"] = "sampling"
         if len(candidates) > test_count:
             final_tests = self._balance_and_sample(
                 candidates, test_count, balance_remainder=enable_balance
@@ -454,7 +568,7 @@ async def execute(
         test_manifest: list[dict[str, str | int]] = []
         for i, candidate in enumerate(final_tests, 1):
             test_file = os.path.join(tests_dir, f"{i:02d}.in")
-            ans_file = os.path.join(tests_dir, f"{i:02d}.ans")
+            ans_file = os.path.join(tests_dir, f"{i:02d}{normalized_answer_ext}")
 
             with open(test_file, "w", encoding="utf-8") as f:
                 f.write(candidate.input_data)
@@ -466,7 +580,7 @@ async def execute(
                 {
                     "index": i,
                     "in_file": f"{i:02d}.in",
-                    "ans_file": f"{i:02d}.ans",
+                    "ans_file": f"{i:02d}{normalized_answer_ext}",
                     "type_param": candidate.type_param,
                     "signature": candidate.signature,
                 }
@@ -477,6 +591,7 @@ async def execute(
             json.dump(
                 {
                     "version": 1,
+                    "answer_ext": normalized_answer_ext,
                     "limit_strategy_types": sorted(_LIMIT_STRATEGY_TYPES),
                     "tests": test_manifest,
                 },
@@ -485,6 +600,8 @@ async def execute(
                 indent=2,
             )
 
+        if os.path.exists(state_path):
+            os.remove(state_path)
         # 统计信息
         type_counts: dict[str, int] = {}
         for c in final_tests:
@@ -512,14 +629,29 @@ async def execute(
                 limit_case_quota_met=limit_quota_met,
                 candidates_generated=len(candidates),
                 sol_name=effective_sol_name,
+                answer_ext=normalized_answer_ext,
+                progress_snapshot=progress_snapshot,
                 message=f"Generated {len(generated_tests)} test cases (from {len(candidates)} candidates)",
             )
         else:
+            self._save_state(
+                state_path,
+                phase="partial",
+                next_seed=seed,
+                candidates=candidates,
+                errors=errors,
+                answer_ext=normalized_answer_ext,
+                active_pids=active_pids,
+                message="Partial generation result",
+            )
             return ToolResult.fail(
                 f"Partial generation: {len(generated_tests)}/{test_count}",
                 generated_tests=generated_tests,
                 errors=errors,
                 sol_name=effective_sol_name,
+                answer_ext=normalized_answer_ext,
+                progress_snapshot=progress_snapshot,
+                resume_hint="Set resume=true to continue from checkpoint",
                 limit_case_count=limit_in_final,
                 limit_case_minimum_required=limit_minimum,
                 limit_case_quota_met=limit_quota_met,
@@ -567,14 +699,15 @@ def _resolve_tests_dir(
 
         return tests_dir, None
 
-    def _clear_generated_tests(self, tests_dir: str) -> ToolResult | None:
-        """创建测试目录并清理旧的 .in/.ans 文件。"""
+    def _clear_generated_tests(self, tests_dir: str, answer_ext: str = ".ans") -> ToolResult | None:
+        """创建测试目录并清理旧的 .in/.answer_ext 文件。"""
         os.makedirs(tests_dir, exist_ok=True)
         for filename in os.listdir(tests_dir):
             if not (
                 filename.endswith(".in")
-                or filename.endswith(".ans")
+                or filename.endswith(answer_ext)
                 or filename == _TEST_MANIFEST_FILENAME
+                or filename == _GENERATE_STATE_FILENAME
             ):
                 continue
             path = os.path.join(tests_dir, filename)
@@ -582,6 +715,117 @@ def _clear_generated_tests(self, tests_dir: str) -> ToolResult | None:
                 os.remove(path)
         return None
 
+    def _normalize_answer_ext(self, answer_ext: str) -> tuple[str | None, ToolResult | None]:
+        ext = (answer_ext or ".ans").strip()
+        if not ext:
+            return None, ToolResult.fail("answer_ext cannot be empty")
+        if not ext.startswith("."):
+            ext = f".{ext}"
+        if any(ch in ext for ch in ('/', '\\', ':', '*', '?', '"', "<", ">", "|")):
+            return None, ToolResult.fail("answer_ext contains illegal characters")
+        if ext == ".in":
+            return None, ToolResult.fail("answer_ext cannot be .in")
+        return ext, None
+
+    async def _run_with_retry(
+        self,
+        binary_path: str,
+        args: list[str],
+        timeout: int,
+        active_pids: set[int],
+    ) -> object:
+        last_result = None
+        for attempt in range(3):
+            started_pid: int | None = None
+            cancelled = False
+
+            def _on_start(pid: int) -> None:
+                nonlocal started_pid
+                started_pid = pid
+                active_pids.add(pid)
+
+            try:
+                last_result = await run_binary_with_args(
+                    binary_path,
+                    args,
+                    timeout=timeout,
+                    process_start_hook=_on_start,
+                )
+            except asyncio.CancelledError:
+                cancelled = True
+                raise
+            finally:
+                # 取消路径保留 PID 到状态文件，供 cleanup 精准回收。
+                if started_pid is not None and not cancelled:
+                    active_pids.discard(started_pid)
+            if not getattr(last_result, "error", None):
+                return last_result
+            await asyncio.sleep(0.1 * (2**attempt))
+        return last_result
+
+    def _save_state(
+        self,
+        state_path: str,
+        *,
+        phase: str,
+        next_seed: int,
+        candidates: list[CandidateTest],
+        errors: list[tuple[int, str]],
+        answer_ext: str,
+        active_pids: set[int] | None = None,
+        message: str | None = None,
+    ) -> None:
+        os.makedirs(os.path.dirname(state_path), exist_ok=True)
+        with open(state_path, "w", encoding="utf-8") as f:
+            json.dump(
+                {
+                    "version": 1,
+                    "phase": phase,
+                    "next_seed": next_seed,
+                    "answer_ext": answer_ext,
+                    "message": message,
+                    "active_pids": sorted(active_pids or []),
+                    "candidates": [
+                        {
+                            "input_data": c.input_data,
+                            "output_data": c.output_data,
+                            "type_param": c.type_param,
+                            "signature": c.signature,
+                        }
+                        for c in candidates
+                    ],
+                    "errors": [{"seed": seed, "error": err} for seed, err in errors[-200:]],
+                },
+                f,
+                ensure_ascii=False,
+                indent=2,
+            )
+
+    def _load_state(self, state_path: str) -> dict | None:
+        if not os.path.exists(state_path):
+            return None
+        try:
+            with open(state_path, encoding="utf-8") as f:
+                return json.load(f)
+        except (OSError, json.JSONDecodeError):
+            return None
+
+    def _restore_candidates(self, raw_candidates: list[dict]) -> list[CandidateTest]:
+        out: list[CandidateTest] = []
+        for item in raw_candidates:
+            if not isinstance(item, dict):
+                continue
+            out.append(
+                CandidateTest(
+                    input_data=str(item.get("input_data", "")),
+                    output_data=str(item.get("output_data", "")),
+                    type_param=str(item.get("type_param", "2")),
+                    signature=str(item.get("signature", "")),
+                )
+            )
+        return out
+
+
     def _balance_and_sample(
         self,
         candidates: list[CandidateTest],
@@ -751,6 +995,105 @@ def _get_default_configs(
         return configs
 
 
+class ProblemCleanupProcessesTool(Tool):
+    """清理 problem_generate_tests 残留状态和进程。"""
+
+    @property
+    def name(self) -> str:
+        return "problem_cleanup_processes"
+
+    @property
+    def description(self) -> str:
+        return "清理生成器残留进程与状态文件。"
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "problem_dir": {"type": "string", "description": "题目目录路径"},
+                "kill_all_generators": {
+                    "type": "boolean",
+                    "description": "是否尝试清理当前问题任务记录的 generator PID（不会全局按进程名误杀）",
+                    "default": False,
+                },
+            },
+            "required": ["problem_dir"],
+        }
+
+    async def execute(self, problem_dir: str, kill_all_generators: bool = False) -> ToolResult:
+        tests_dir = os.path.join(problem_dir, "tests")
+        state_path = os.path.join(tests_dir, _GENERATE_STATE_FILENAME)
+        state = self._load_cleanup_state(state_path) or {}
+        removed_files: list[str] = []
+        pids = state.get("active_pids", []) if isinstance(state, dict) else []
+        if not isinstance(pids, list):
+            pids = []
+        if kill_all_generators and os.name == "nt":
+            try:
+                killed: list[int] = []
+                failed: list[dict[str, str | int]] = []
+                for pid in pids:
+                    if not isinstance(pid, int) or pid <= 0:
+                        continue
+                    proc = await asyncio.create_subprocess_exec(
+                        "taskkill",
+                        "/PID",
+                        str(pid),
+                        "/F",
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                    )
+                    stdout, stderr = await proc.communicate()
+                    if proc.returncode == 0:
+                        killed.append(pid)
+                    else:
+                        failed.append(
+                            {
+                                "pid": pid,
+                                "stdout": stdout.decode("utf-8", errors="replace"),
+                                "stderr": stderr.decode("utf-8", errors="replace"),
+                            }
+                        )
+                # 仅移除已成功清理的 PID；失败 PID 保留，支持后续重试。
+                remaining_pids = [pid for pid in pids if isinstance(pid, int) and pid not in killed]
+                self._write_cleanup_state(state_path, remaining_pids)
+                if not remaining_pids and os.path.exists(state_path):
+                    os.remove(state_path)
+                    removed_files.append(state_path)
+                return ToolResult.ok(
+                    removed_files=removed_files,
+                    killed_pids=killed,
+                    failed_pids=failed,
+                    warning="No tracked generator PID found; skipped process termination" if not pids else "",
+                    message="Cleanup finished",
+                )
+            except Exception as exc:
+                return ToolResult.fail(f"cleanup failed: {exc}", removed_files=removed_files)
+        # 非 Windows 或未请求 kill：仅在无 PID 时删除空状态文件。
+        if os.path.exists(state_path) and not pids:
+            os.remove(state_path)
+            removed_files.append(state_path)
+        return ToolResult.ok(removed_files=removed_files, message="Cleanup finished")
+
+    def _load_cleanup_state(self, state_path: str) -> dict | None:
+        if not os.path.exists(state_path):
+            return None
+        try:
+            with open(state_path, encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, dict):
+                return data
+        except (OSError, json.JSONDecodeError):
+            return None
+        return None
+
+    def _write_cleanup_state(self, state_path: str, remaining_pids: list[int]) -> None:
+        os.makedirs(os.path.dirname(state_path), exist_ok=True)
+        with open(state_path, "w", encoding="utf-8") as f:
+            json.dump({"active_pids": remaining_pids}, f, ensure_ascii=False, indent=2)
+
+
 class ProblemPackPolygonTool(Tool):
     """打包为 Polygon 格式。"""
 
@@ -855,8 +1198,20 @@ async def execute(
             if os.path.exists(tests_dir):
                 test_files = [f for f in os.listdir(tests_dir) if f.endswith(".in")]
                 actual_test_count = len(test_files)
+                manifest_path = os.path.join(tests_dir, _TEST_MANIFEST_FILENAME)
+                answer_ext = ".ans"
+                if os.path.exists(manifest_path):
+                    try:
+                        with open(manifest_path, encoding="utf-8") as mf:
+                            manifest = json.load(mf)
+                        answer_ext = str(manifest.get("answer_ext", ".ans"))
+                        if not answer_ext.startswith("."):
+                            answer_ext = f".{answer_ext}"
+                    except (OSError, json.JSONDecodeError):
+                        answer_ext = ".ans"
             else:
                 actual_test_count = 0
+                answer_ext = ".ans"
 
             problem_name = os.path.basename(problem_dir)
             xml_content = f'''<?xml version="1.0" encoding="utf-8" standalone="no"?>
@@ -873,7 +1228,7 @@ async def execute(
             <memory-limit>{memory_limit_bytes}</memory-limit>
             <test-count>{actual_test_count}</test-count>
             <input-path-pattern>tests/%02d.in</input-path-pattern>
-            <answer-path-pattern>tests/%02d.ans</answer-path-pattern>
+            <answer-path-pattern>tests/%02d{answer_ext}</answer-path-pattern>
         </testset>
     </judging>
     <files>
diff --git a/src/autocode_mcp/tools/test_verify.py b/src/autocode_mcp/tools/test_verify.py
index d0dafb6..19a773f 100644
--- a/src/autocode_mcp/tools/test_verify.py
+++ b/src/autocode_mcp/tools/test_verify.py
@@ -68,6 +68,7 @@ def input_schema(self) -> dict:
                             "validator",
                             "no_empty",
                             "limit_ratio",
+                            "limit_semantics",
                         ],
                     },
                     "description": "要执行的验证类型，默认全部执行",
@@ -81,6 +82,10 @@ def input_schema(self) -> dict:
                     "description": "是否启用 extreme/tle 占比检查（默认开启；设为 false 可关闭）",
                     "default": True,
                 },
+                "answer_ext": {
+                    "type": "string",
+                    "description": "答案文件后缀，默认自动从 manifest 推断（否则使用 .ans）",
+                },
                 "timeout": {
                     "type": "integer",
                     "description": "单次执行超时（秒）",
@@ -97,6 +102,7 @@ async def execute(
         verify_types: list[str] | None = None,
         sol_name: str | None = None,
         enable_limit_ratio: bool = True,
+        answer_ext: str | None = None,
         timeout: int = 60,
     ) -> ToolResult:
         """执行测试数据验证。"""
@@ -112,6 +118,8 @@ async def execute(
         if not os.path.exists(tests_dir):
             return ToolResult.fail(f"Tests directory not found: {tests_dir}")
 
+        resolved_answer_ext = self._resolve_answer_ext(tests_dir, answer_ext)
+
         # 默认执行所有验证
         if not verify_types:
             verify_types = ["file_count", "answer_consistency", "validator", "no_empty"]
@@ -119,15 +127,17 @@ async def execute(
         if enable_limit_ratio:
             if "limit_ratio" not in verify_types:
                 verify_types.append("limit_ratio")
+            if "limit_semantics" not in verify_types:
+                verify_types.append("limit_semantics")
         else:
-            verify_types = [v for v in verify_types if v != "limit_ratio"]
+            verify_types = [v for v in verify_types if v not in {"limit_ratio", "limit_semantics"}]
 
         results = {}
         all_passed = True
 
         # 1. 文件完整性检查
         if "file_count" in verify_types:
-            result = self._check_file_count(tests_dir)
+            result = self._check_file_count(tests_dir, resolved_answer_ext)
             results["file_count"] = result
             if not result["passed"]:
                 all_passed = False
@@ -145,6 +155,7 @@ async def execute(
                 problem_dir,
                 tests_dir,
                 effective_sol_name,
+                resolved_answer_ext,
                 timeout,
             )
             results["answer_consistency"] = result
@@ -164,6 +175,11 @@ async def execute(
             results["limit_ratio"] = result
             if not result["passed"]:
                 all_passed = False
+        if "limit_semantics" in verify_types:
+            result = self._check_limit_semantics(tests_dir)
+            results["limit_semantics"] = result
+            if not result["passed"]:
+                all_passed = False
 
         # 汇总
         total_checks = len(results)
@@ -192,23 +208,26 @@ async def execute(
                 limit_ratio_enabled=enable_limit_ratio,
             )
 
-    def _check_file_count(self, tests_dir: str) -> dict:
-        """检查文件完整性：每个 .in 有对应的 .ans。"""
+    def _check_file_count(self, tests_dir: str, answer_ext: str) -> dict:
+        """检查文件完整性：每个 .in 有对应的 answer_ext。"""
         tests_path = Path(tests_dir)
         in_files = sorted(p.name for p in tests_path.iterdir() if p.is_file() and p.suffix == ".in")
-        ans_files = sorted(p.name for p in tests_path.iterdir() if p.is_file() and p.suffix == ".ans")
+        ans_files = sorted(p.name for p in tests_path.iterdir() if p.is_file() and p.name.endswith(answer_ext))
         ans_file_set = set(ans_files)
         in_file_set = set(in_files)
 
         missing_ans = []
         for in_file in in_files:
-            ans_file = Path(in_file).with_suffix(".ans").name
+            ans_file = Path(in_file).with_suffix(answer_ext).name
             if ans_file not in ans_file_set:
                 missing_ans.append(in_file)
 
         orphan_ans = []
         for ans_file in ans_files:
-            in_file = Path(ans_file).with_suffix(".in").name
+            if not ans_file.endswith(answer_ext):
+                continue
+            base = ans_file[: -len(answer_ext)]
+            in_file = f"{base}.in"
             if in_file not in in_file_set:
                 orphan_ans.append(ans_file)
 
@@ -255,7 +274,7 @@ def _check_no_empty(self, tests_dir: str) -> dict:
         }
 
     async def _check_answer_consistency(
-        self, problem_dir: str, tests_dir: str, sol_name: str, timeout: int
+        self, problem_dir: str, tests_dir: str, sol_name: str, answer_ext: str, timeout: int
     ) -> dict:
         """用 sol 重新运行 .in，对比输出与 .ans。"""
         exe_ext = get_exe_extension()
@@ -281,7 +300,7 @@ async def _check_answer_consistency(
 
         for in_file in in_files:
             in_path = os.path.join(tests_dir, in_file)
-            ans_file = Path(in_file).with_suffix(".ans").name
+            ans_file = Path(in_file).with_suffix(answer_ext).name
             ans_path = os.path.join(tests_dir, ans_file)
 
             if not os.path.exists(ans_path):
@@ -444,3 +463,46 @@ def _check_limit_ratio(self, tests_dir: str) -> dict:
             "limit_case_ratio": ratio,
             "limit_strategy_types": sorted(_LIMIT_STRATEGY_TYPES),
         }
+
+    def _check_limit_semantics(self, tests_dir: str) -> dict:
+        manifest_path = os.path.join(tests_dir, _TEST_MANIFEST_FILENAME)
+        if not os.path.exists(manifest_path):
+            return {"passed": False, "error": f"manifest not found: {manifest_path}"}
+        try:
+            with open(manifest_path, encoding="utf-8") as f:
+                manifest = json.load(f)
+        except (json.JSONDecodeError, OSError) as exc:
+            return {"passed": False, "error": f"failed to read manifest: {exc}"}
+        tests = manifest.get("tests", [])
+        type3 = [t for t in tests if isinstance(t, dict) and t.get("type_param") == "3"]
+        type4 = [t for t in tests if isinstance(t, dict) and t.get("type_param") == "4"]
+        if not type4:
+            return {"passed": False, "error": "type=4 cases missing; update generator first"}
+        if not type3:
+            return {"passed": False, "error": "type=3 cases missing; update generator first"}
+        sig3 = {str(t.get("signature", "")) for t in type3}
+        sig4 = {str(t.get("signature", "")) for t in type4}
+        overlap_ratio = len(sig3 & sig4) / max(1, min(len(sig3), len(sig4)))
+        passed = overlap_ratio < 0.8
+        return {
+            "passed": passed,
+            "type3_count": len(type3),
+            "type4_count": len(type4),
+            "overlap_ratio": overlap_ratio,
+            "hint": "需要确保 type=4 不是仅放大参数，而是有独立卡法" if not passed else "",
+        }
+
+    def _resolve_answer_ext(self, tests_dir: str, answer_ext: str | None) -> str:
+        if answer_ext:
+            return answer_ext if answer_ext.startswith(".") else f".{answer_ext}"
+        manifest_path = os.path.join(tests_dir, _TEST_MANIFEST_FILENAME)
+        if os.path.exists(manifest_path):
+            try:
+                with open(manifest_path, encoding="utf-8") as f:
+                    manifest = json.load(f)
+                ext = manifest.get("answer_ext")
+                if isinstance(ext, str) and ext:
+                    return ext if ext.startswith(".") else f".{ext}"
+            except (json.JSONDecodeError, OSError):
+                pass
+        return ".ans"
diff --git a/src/autocode_mcp/utils/compiler.py b/src/autocode_mcp/utils/compiler.py
index aaa07c4..2a65ee9 100644
--- a/src/autocode_mcp/utils/compiler.py
+++ b/src/autocode_mcp/utils/compiler.py
@@ -15,6 +15,7 @@
 import shutil
 import sys
 import uuid
+from collections.abc import Callable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
@@ -271,6 +272,7 @@ async def _run_process(
     stdin: str = "",
     timeout: int = 5,
     memory_mb: int = 256,
+    process_start_hook: Callable[[int], None] | None = None,
 ) -> RunResult:
     """运行进程的公共逻辑。"""
     import time
@@ -295,7 +297,12 @@ async def _run_process(
                     job.assign_process(process.pid)
                 except (OSError, RuntimeError) as e:
                     # Job Object 创建/分配失败，记录日志并继续（进程仍可运行）
-                    _logger.warning("Failed to setup Windows Job Object: %s", e)
+                    _logger.warning(
+                        "Failed to setup Windows Job Object (pid=%s, cmd=%s): %s",
+                        process.pid,
+                        cmd[0] if cmd else "",
+                        e,
+                    )
                     job = None
         elif sys.platform == "darwin":
             # macOS: 使用 preexec_fn 设置资源限制
@@ -319,6 +326,12 @@ async def _run_process(
                 stderr=asyncio.subprocess.PIPE,
             )
 
+        if process and process.pid and process_start_hook:
+            try:
+                process_start_hook(process.pid)
+            except Exception as e:
+                _logger.debug("process_start_hook failed: %s", e)
+
         try:
             # Windows 上 testlib strict 模式期望 CRLF 换行符
             # 将 LF 转换为 CRLF 以满足 validator 的 readEoln() 要求
@@ -331,6 +344,10 @@ async def _run_process(
                 process.communicate(input=processed_stdin.encode("utf-8") if processed_stdin else None),
                 timeout=timeout,
             )
+        except asyncio.CancelledError:
+            # 调用被取消时也必须强制清理子进程，防止残留。
+            await _force_terminate_process(process, job)
+            raise
         except TimeoutError:
             # 超时时强制终止进程
             await _force_terminate_process(process, job)
@@ -343,9 +360,9 @@ async def _run_process(
 
         elapsed_ms = int((time.time() - start_time) * 1000)
 
-        # 正常完成后清理 Job Object
+        # 正常完成后只关闭 Job Handle
         if job:
-            job.terminate()
+            job.close()
 
         return RunResult(
             success=process.returncode == 0,
@@ -375,6 +392,7 @@ async def run_binary(
     stdin: str = "",
     timeout: int = 5,
     memory_mb: int = 256,
+    process_start_hook: Callable[[int], None] | None = None,
 ) -> RunResult:
     """
     运行二进制文件，带超时和内存限制。
@@ -394,7 +412,7 @@ async def run_binary(
             error=f"Binary not found: {binary_path}",
         )
 
-    return await _run_process([binary_path], stdin, timeout, memory_mb)
+    return await _run_process([binary_path], stdin, timeout, memory_mb, process_start_hook)
 
 
 async def run_binary_with_args(
@@ -403,6 +421,7 @@ async def run_binary_with_args(
     stdin: str = "",
     timeout: int = 5,
     memory_mb: int = 256,
+    process_start_hook: Callable[[int], None] | None = None,
 ) -> RunResult:
     """
     运行二进制文件并传递命令行参数。
@@ -423,7 +442,13 @@ async def run_binary_with_args(
             error=f"Binary not found: {binary_path}",
         )
 
-    return await _run_process([binary_path, *args], stdin, timeout, memory_mb)
+    return await _run_process(
+        [binary_path, *args],
+        stdin,
+        timeout,
+        memory_mb,
+        process_start_hook,
+    )
 
 
 async def compile_all(
diff --git a/src/autocode_mcp/utils/win_job.py b/src/autocode_mcp/utils/win_job.py
index 74a5acf..70e2e51 100644
--- a/src/autocode_mcp/utils/win_job.py
+++ b/src/autocode_mcp/utils/win_job.py
@@ -140,6 +140,12 @@ def terminate(self) -> None:
             win32api.CloseHandle(self.job_handle)
             self.job_handle = None
 
+    def close(self) -> None:
+        """关闭 Job Object 句柄（不主动终止进程）。"""
+        if self.job_handle is not None and self.job_handle != 0:
+            win32api.CloseHandle(self.job_handle)
+            self.job_handle = None
+
     def __enter__(self) -> WinJobObject:
         """上下文管理器入口。"""
         return self
diff --git a/tests/test_compiler.py b/tests/test_compiler.py
index 9321cdb..ab1776d 100644
--- a/tests/test_compiler.py
+++ b/tests/test_compiler.py
@@ -4,11 +4,13 @@
 测试 C++ 编译和执行的核心功能。
 """
 
+import asyncio
 import os
 import tempfile
 
 import pytest
 
+import autocode_mcp.utils.compiler as compiler_module
 from autocode_mcp.utils.compiler import (
     CompileResult,
     cleanup_work_dir,
@@ -363,3 +365,39 @@ async def test_run_binary_with_memory_limit():
             pass
         else:
             pass
+
+
+@pytest.mark.asyncio
+async def test_run_binary_with_args_cancelled_force_terminates(monkeypatch):
+    """CancelledError 路径应强制终止子进程。"""
+    killed = {"value": False}
+
+    class FakeProcess:
+        def __init__(self):
+            self.pid = 1234
+            self.returncode = None
+
+        async def communicate(self, input=None):
+            raise asyncio.CancelledError()
+
+        def kill(self):
+            killed["value"] = True
+            self.returncode = -9
+
+        async def wait(self):
+            return self.returncode
+
+    async def fake_create_subprocess_exec(*args, **kwargs):
+        return FakeProcess()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        binary_path = os.path.join(tmpdir, "dummy.exe")
+        with open(binary_path, "w", encoding="utf-8") as f:
+            f.write("x")
+
+        monkeypatch.setattr(compiler_module.sys, "platform", "linux")
+        monkeypatch.setattr(compiler_module.asyncio, "create_subprocess_exec", fake_create_subprocess_exec)
+
+        with pytest.raises(asyncio.CancelledError):
+            await run_binary_with_args(binary_path, ["1"], timeout=1)
+        assert killed["value"] is True
diff --git a/tests/test_tools/test_generator.py b/tests/test_tools/test_generator.py
index 9a22484..04ac30c 100644
--- a/tests/test_tools/test_generator.py
+++ b/tests/test_tools/test_generator.py
@@ -40,6 +40,22 @@
 }
 """
 
+WEAK_GENERATOR_CODE = """
+#include "testlib.h"
+#include <iostream>
+int main(int argc, char* argv[]) {
+    registerGen(argc, argv, 1);
+    int type = atoi(argv[2]);
+    int n_max = atoi(argv[4]);
+    if (type == 3) {
+        std::cout << n_max << "\\n";
+    } else if (type == 4) {
+        std::cout << n_max << "\\n";
+    }
+    return 0;
+}
+"""
+
 
 @pytest.mark.asyncio
 async def test_generator_build():
@@ -55,6 +71,7 @@ async def test_generator_build():
         assert result.success
         assert os.path.exists(result.data["source_path"])
         assert os.path.exists(result.data["binary_path"])
+        assert "semantic_check" in result.data
 
 
 @pytest.mark.asyncio
@@ -162,3 +179,17 @@ async def test_generator_run_with_custom_params():
             lines = inp["input"].strip().split("\n")
             n = int(lines[0])
             assert 5 <= n <= 10
+
+
+@pytest.mark.asyncio
+async def test_generator_build_strict_semantic_check():
+    """严格语义检查下，type3/type4 同构应构建失败。"""
+    tool = GeneratorBuildTool()
+    with tempfile.TemporaryDirectory() as tmpdir:
+        result = await tool.execute(
+            problem_dir=tmpdir,
+            code=WEAK_GENERATOR_CODE,
+            strict_semantic_check=True,
+        )
+        assert not result.success
+        assert "semantic" in result.error.lower()
diff --git a/tests/test_tools/test_problem.py b/tests/test_tools/test_problem.py
index c052980..1e906b5 100644
--- a/tests/test_tools/test_problem.py
+++ b/tests/test_tools/test_problem.py
@@ -2,6 +2,7 @@
 Problem 工具组测试。
 """
 
+import asyncio
 import json
 import os
 import tempfile
@@ -11,6 +12,7 @@
 from autocode_mcp.tools.generator import GeneratorBuildTool
 from autocode_mcp.tools.problem import (
     CandidateTest,
+    ProblemCleanupProcessesTool,
     ProblemCreateTool,
     ProblemGenerateTestsTool,
     ProblemPackPolygonTool,
@@ -376,6 +378,32 @@ def test_problem_generate_tests_clear_only_generated_files():
         assert not os.path.exists(old_ans_path)
 
 
+def test_problem_generate_tests_clear_only_generated_files_with_custom_answer_ext():
+    """测试清理输出目录时可按自定义答案后缀删除文件。"""
+    tool = ProblemGenerateTestsTool()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tests_dir = os.path.join(tmpdir, "tests")
+        os.makedirs(tests_dir)
+        keep_path = os.path.join(tests_dir, "notes.txt")
+        old_in_path = os.path.join(tests_dir, "01.in")
+        old_out_path = os.path.join(tests_dir, "01.out")
+
+        with open(keep_path, "w", encoding="utf-8") as f:
+            f.write("keep me")
+        with open(old_in_path, "w", encoding="utf-8") as f:
+            f.write("old input")
+        with open(old_out_path, "w", encoding="utf-8") as f:
+            f.write("old answer")
+
+        result = tool._clear_generated_tests(tests_dir, ".out")
+
+        assert result is None
+        assert os.path.exists(keep_path)
+        assert not os.path.exists(old_in_path)
+        assert not os.path.exists(old_out_path)
+
+
 @pytest.mark.asyncio
 async def test_problem_generate_tests_uses_custom_sol_name(monkeypatch):
     """测试生成答案时使用自定义 sol_name。"""
@@ -417,6 +445,91 @@ async def fake_run_binary(binary_path, stdin="", timeout=5, memory_mb=256):
         assert os.path.exists(os.path.join(problem_dir, "tests", "01.ans"))
 
 
+@pytest.mark.asyncio
+async def test_problem_generate_tests_supports_custom_answer_ext(monkeypatch):
+    """测试生成答案时支持自定义 answer_ext。"""
+    tool = ProblemGenerateTestsTool()
+
+    async def fake_run_binary_with_args(*args, **kwargs):
+        return RunResult(success=True, stdout="7\n")
+
+    async def fake_run_binary(binary_path, stdin="", timeout=5, memory_mb=256):
+        return RunResult(success=True, stdout="7\n")
+
+    monkeypatch.setattr("autocode_mcp.tools.problem.run_binary_with_args", fake_run_binary_with_args)
+    monkeypatch.setattr("autocode_mcp.tools.problem.run_binary", fake_run_binary)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        problem_dir = os.path.join(tmpdir, "custom_ext")
+        files_dir = os.path.join(problem_dir, "files")
+        solutions_dir = os.path.join(problem_dir, "solutions")
+        os.makedirs(files_dir)
+        os.makedirs(solutions_dir)
+
+        exe_ext = get_exe_extension()
+        open(os.path.join(files_dir, f"gen{exe_ext}"), "w").close()
+        open(os.path.join(solutions_dir, f"sol{exe_ext}"), "w").close()
+
+        result = await tool.execute(
+            problem_dir=problem_dir,
+            test_count=1,
+            answer_ext=".out",
+            enable_dedup=False,
+            oversample_ratio=1.0,
+        )
+
+        assert result.success
+        assert result.data["answer_ext"] == ".out"
+        assert os.path.exists(os.path.join(problem_dir, "tests", "01.in"))
+        assert os.path.exists(os.path.join(problem_dir, "tests", "01.out"))
+
+
+@pytest.mark.asyncio
+async def test_problem_generate_tests_resume_without_state_falls_back_to_fresh(monkeypatch):
+    """resume=true 且无状态文件时应回退 fresh run 并清理旧测试。"""
+    tool = ProblemGenerateTestsTool()
+
+    async def fake_run_binary_with_args(*args, **kwargs):
+        return RunResult(success=True, stdout="9\n")
+
+    async def fake_run_binary(binary_path, stdin="", timeout=5, memory_mb=256):
+        return RunResult(success=True, stdout="9\n")
+
+    monkeypatch.setattr("autocode_mcp.tools.problem.run_binary_with_args", fake_run_binary_with_args)
+    monkeypatch.setattr("autocode_mcp.tools.problem.run_binary", fake_run_binary)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        problem_dir = os.path.join(tmpdir, "resume_fallback")
+        files_dir = os.path.join(problem_dir, "files")
+        solutions_dir = os.path.join(problem_dir, "solutions")
+        tests_dir = os.path.join(problem_dir, "tests")
+        os.makedirs(files_dir)
+        os.makedirs(solutions_dir)
+        os.makedirs(tests_dir)
+
+        exe_ext = get_exe_extension()
+        open(os.path.join(files_dir, f"gen{exe_ext}"), "w").close()
+        open(os.path.join(solutions_dir, f"sol{exe_ext}"), "w").close()
+
+        with open(os.path.join(tests_dir, "02.in"), "w", encoding="utf-8") as f:
+            f.write("stale\n")
+        with open(os.path.join(tests_dir, "02.ans"), "w", encoding="utf-8") as f:
+            f.write("stale\n")
+
+        result = await tool.execute(
+            problem_dir=problem_dir,
+            test_count=1,
+            resume=True,
+            enable_dedup=False,
+            oversample_ratio=1.0,
+        )
+
+        assert result.success
+        assert result.data["progress_snapshot"].get("resume_fallback") is True
+        assert not os.path.exists(os.path.join(tests_dir, "02.in"))
+        assert not os.path.exists(os.path.join(tests_dir, "02.ans"))
+
+
 def test_problem_verify_tests_file_count_requires_contiguous_numeric_names():
     """测试 file_count 会检查数字文件名连续性。"""
     tool = ProblemVerifyTestsTool()
@@ -426,7 +539,7 @@ def test_problem_verify_tests_file_count_requires_contiguous_numeric_names():
             with open(os.path.join(tmpdir, name), "w", encoding="utf-8") as f:
                 f.write("x\n")
 
-        result = tool._check_file_count(tmpdir)
+        result = tool._check_file_count(tmpdir, ".ans")
 
         assert not result["passed"]
         assert result["missing_indices"] == [2]
@@ -441,7 +554,7 @@ def test_problem_verify_tests_file_count_reports_large_gaps():
             with open(os.path.join(tmpdir, name), "w", encoding="utf-8") as f:
                 f.write("x\n")
 
-        result = tool._check_file_count(tmpdir)
+        result = tool._check_file_count(tmpdir, ".ans")
 
         assert not result["passed"]
         assert result["missing_indices"][0] == 2
@@ -520,6 +633,157 @@ def test_problem_verify_tests_limit_ratio_fails_when_insufficient():
         assert result["limit_case_minimum_required"] == 3
 
 
+def test_problem_verify_tests_limit_semantics_fails_for_overlapping_signatures():
+    """测试 type3/type4 签名高度重叠时触发语义门禁。"""
+    tool = ProblemVerifyTestsTool()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        with open(os.path.join(tmpdir, "01.in"), "w", encoding="utf-8") as f:
+            f.write("x\n")
+        manifest = {
+            "version": 1,
+            "tests": [
+                {"in_file": "01.in", "ans_file": "01.ans", "type_param": "3", "signature": "same"},
+                {"in_file": "02.in", "ans_file": "02.ans", "type_param": "4", "signature": "same"},
+            ],
+        }
+        with open(os.path.join(tmpdir, ".autocode_tests_manifest.json"), "w", encoding="utf-8") as f:
+            json.dump(manifest, f)
+        result = tool._check_limit_semantics(tmpdir)
+        assert result["passed"] is False
+
+
+def test_problem_verify_tests_file_count_supports_multi_part_answer_ext():
+    """多段后缀（如 .a.out）不应误报 orphan。"""
+    tool = ProblemVerifyTestsTool()
+    with tempfile.TemporaryDirectory() as tmpdir:
+        for name in ["01.in", "01.a.out"]:
+            with open(os.path.join(tmpdir, name), "w", encoding="utf-8") as f:
+                f.write("x\n")
+        result = tool._check_file_count(tmpdir, ".a.out")
+        assert result["passed"] is True
+        assert result["orphan_ans"] == []
+
+
+@pytest.mark.asyncio
+async def test_problem_verify_tests_supports_custom_answer_ext():
+    """测试 verify 可读取自定义答案后缀。"""
+    tool = ProblemVerifyTestsTool()
+    with tempfile.TemporaryDirectory() as tmpdir:
+        with open(os.path.join(tmpdir, "01.in"), "w", encoding="utf-8") as f:
+            f.write("1\n")
+        with open(os.path.join(tmpdir, "01.out"), "w", encoding="utf-8") as f:
+            f.write("1\n")
+        manifest = {
+            "version": 1,
+            "answer_ext": ".out",
+            "tests": [{"in_file": "01.in", "ans_file": "01.out", "type_param": "3", "signature": "a"}],
+        }
+        with open(os.path.join(tmpdir, ".autocode_tests_manifest.json"), "w", encoding="utf-8") as f:
+            json.dump(manifest, f)
+        result = await tool.execute(
+            problem_dir=tmpdir,
+            tests_dir=tmpdir,
+            verify_types=["file_count", "no_empty"],
+            enable_limit_ratio=False,
+        )
+        assert result.success
+
+
+@pytest.mark.asyncio
+async def test_problem_cleanup_processes_does_not_global_kill_without_tracked_pids():
+    """cleanup 不应在无 tracked PID 时按进程名全局误杀。"""
+    tool = ProblemCleanupProcessesTool()
+    with tempfile.TemporaryDirectory() as tmpdir:
+        result = await tool.execute(problem_dir=tmpdir, kill_all_generators=True)
+        assert result.success
+        assert "warning" in result.data
+
+
+@pytest.mark.asyncio
+async def test_problem_cleanup_processes_kills_tracked_pids(monkeypatch):
+    """cleanup 应按状态文件里的 PID 精准清理。"""
+    tool = ProblemCleanupProcessesTool()
+    called_cmds: list[list[str]] = []
+
+    class _FakeProc:
+        def __init__(self):
+            self.returncode = 0
+
+        async def communicate(self):
+            return b"ok", b""
+
+    async def fake_create_subprocess_exec(*args, **kwargs):
+        called_cmds.append([str(a) for a in args])
+        return _FakeProc()
+
+    monkeypatch.setattr("autocode_mcp.tools.problem.asyncio.create_subprocess_exec", fake_create_subprocess_exec)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tests_dir = os.path.join(tmpdir, "tests")
+        os.makedirs(tests_dir, exist_ok=True)
+        with open(os.path.join(tests_dir, ".autocode_generate_state.json"), "w", encoding="utf-8") as f:
+            json.dump({"active_pids": [12345, 23456]}, f)
+        result = await tool.execute(problem_dir=tmpdir, kill_all_generators=True)
+        assert result.success
+        assert result.data.get("killed_pids") == [12345, 23456]
+        assert len(called_cmds) == 2
+
+
+@pytest.mark.asyncio
+async def test_problem_cleanup_processes_keeps_failed_pid_for_retry(monkeypatch):
+    """cleanup 失败 PID 应保留在状态文件中，支持后续重试。"""
+    tool = ProblemCleanupProcessesTool()
+    calls = {"count": 0}
+
+    class _FakeProc:
+        def __init__(self, rc):
+            self.returncode = rc
+
+        async def communicate(self):
+            return b"", b"failed" if self.returncode != 0 else b""
+
+    async def fake_create_subprocess_exec(*args, **kwargs):
+        calls["count"] += 1
+        # 第一个 PID 成功，第二个失败
+        return _FakeProc(0 if calls["count"] == 1 else 1)
+
+    monkeypatch.setattr("autocode_mcp.tools.problem.asyncio.create_subprocess_exec", fake_create_subprocess_exec)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tests_dir = os.path.join(tmpdir, "tests")
+        os.makedirs(tests_dir, exist_ok=True)
+        state_path = os.path.join(tests_dir, ".autocode_generate_state.json")
+        with open(state_path, "w", encoding="utf-8") as f:
+            json.dump({"active_pids": [111, 222]}, f)
+
+        result = await tool.execute(problem_dir=tmpdir, kill_all_generators=True)
+        assert result.success
+        assert result.data.get("killed_pids") == [111]
+        assert os.path.exists(state_path)
+        with open(state_path, encoding="utf-8") as f:
+            state = json.load(f)
+        assert state.get("active_pids") == [222]
+
+
+@pytest.mark.asyncio
+async def test_problem_generate_tests_run_with_retry_keeps_pid_on_cancel(monkeypatch):
+    """取消时 _run_with_retry 应保留 active_pids 供后续 cleanup 使用。"""
+    tool = ProblemGenerateTestsTool()
+
+    async def fake_run_binary_with_args(binary_path, args, timeout=5, process_start_hook=None, **kwargs):
+        if process_start_hook:
+            process_start_hook(43210)
+        raise asyncio.CancelledError()
+
+    monkeypatch.setattr("autocode_mcp.tools.problem.run_binary_with_args", fake_run_binary_with_args)
+
+    active_pids: set[int] = set()
+    with pytest.raises(asyncio.CancelledError):
+        await tool._run_with_retry("dummy", ["1"], timeout=1, active_pids=active_pids)
+    assert 43210 in active_pids
+
+
 @pytest.mark.asyncio
 async def test_problem_verify_tests_default_enables_limit_ratio():
     """默认会启用 limit_ratio（即使 verify_types 未显式包含）。"""
diff --git a/uv.lock b/uv.lock
index 6301f9b..8f6586c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -57,6 +57,7 @@ dev = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "twine" },
     { name = "types-psutil" },
     { name = "types-pywin32" },
     { name = "types-pyyaml" },
@@ -79,6 +80,7 @@ provides-extras = ["dev"]
 
 [package.metadata.requires-dev]
 dev = [
+    { name = "twine", specifier = ">=6.2.0" },
     { name = "types-psutil", specifier = ">=7.2.2.20260402" },
     { name = "types-pywin32", specifier = ">=311.0.0.20260402" },
     { name = "types-pyyaml", specifier = ">=6.0.12.20250915" },
@@ -93,6 +95,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a0/59/76ab57e3fe74484f48a53f8e337171b4a2349e506eabe136d7e01d059086/backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5", size = 12313, upload-time = "2025-07-02T02:27:14.263Z" },
 ]
 
+[[package]]
+name = "backports-tarfile"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", size = 86406, upload-time = "2024-05-28T17:01:54.731Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181, upload-time = "2024-05-28T17:01:53.112Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2026.2.25"
@@ -184,6 +195,111 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
 ]
 
+[[package]]
+name = "charset-normalizer"
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/08/0f303cb0b529e456bb116f2d50565a482694fbb94340bf56d44677e7ed03/charset_normalizer-3.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cdd68a1fb318e290a2077696b7eb7a21a49163c455979c639bf5a5dcdc46617d", size = 315182, upload-time = "2026-04-02T09:25:40.673Z" },
+    { url = "https://files.pythonhosted.org/packages/24/47/b192933e94b546f1b1fe4df9cc1f84fcdbf2359f8d1081d46dd029b50207/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e17b8d5d6a8c47c85e68ca8379def1303fd360c3e22093a807cd34a71cd082b8", size = 209329, upload-time = "2026-04-02T09:25:42.354Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b4/01fa81c5ca6141024d89a8fc15968002b71da7f825dd14113207113fabbd/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:511ef87c8aec0783e08ac18565a16d435372bc1ac25a91e6ac7f5ef2b0bff790", size = 231230, upload-time = "2026-04-02T09:25:44.281Z" },
+    { url = "https://files.pythonhosted.org/packages/20/f7/7b991776844dfa058017e600e6e55ff01984a063290ca5622c0b63162f68/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:007d05ec7321d12a40227aae9e2bc6dca73f3cb21058999a1df9e193555a9dcc", size = 225890, upload-time = "2026-04-02T09:25:45.475Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e7/bed0024a0f4ab0c8a9c64d4445f39b30c99bd1acd228291959e3de664247/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf29836da5119f3c8a8a70667b0ef5fdca3bb12f80fd06487cfa575b3909b393", size = 216930, upload-time = "2026-04-02T09:25:46.58Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/ab/b18f0ab31cdd7b3ddb8bb76c4a414aeb8160c9810fdf1bc62f269a539d87/charset_normalizer-3.4.7-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:12d8baf840cc7889b37c7c770f478adea7adce3dcb3944d02ec87508e2dcf153", size = 202109, upload-time = "2026-04-02T09:25:48.031Z" },
+    { url = "https://files.pythonhosted.org/packages/82/e5/7e9440768a06dfb3075936490cb82dbf0ee20a133bf0dd8551fa096914ec/charset_normalizer-3.4.7-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d560742f3c0d62afaccf9f41fe485ed69bd7661a241f86a3ef0f0fb8b1a397af", size = 214684, upload-time = "2026-04-02T09:25:49.245Z" },
+    { url = "https://files.pythonhosted.org/packages/71/94/8c61d8da9f062fdf457c80acfa25060ec22bf1d34bbeaca4350f13bcfd07/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b14b2d9dac08e28bb8046a1a0434b1750eb221c8f5b87a68f4fa11a6f97b5e34", size = 212785, upload-time = "2026-04-02T09:25:50.671Z" },
+    { url = "https://files.pythonhosted.org/packages/66/cd/6e9889c648e72c0ab2e5967528bb83508f354d706637bc7097190c874e13/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:bc17a677b21b3502a21f66a8cc64f5bfad4df8a0b8434d661666f8ce90ac3af1", size = 203055, upload-time = "2026-04-02T09:25:51.802Z" },
+    { url = "https://files.pythonhosted.org/packages/92/2e/7a951d6a08aefb7eb8e1b54cdfb580b1365afdd9dd484dc4bee9e5d8f258/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:750e02e074872a3fad7f233b47734166440af3cdea0add3e95163110816d6752", size = 232502, upload-time = "2026-04-02T09:25:53.388Z" },
+    { url = "https://files.pythonhosted.org/packages/58/d5/abcf2d83bf8e0a1286df55cd0dc1d49af0da4282aa77e986df343e7de124/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:4e5163c14bffd570ef2affbfdd77bba66383890797df43dc8b4cc7d6f500bf53", size = 214295, upload-time = "2026-04-02T09:25:54.765Z" },
+    { url = "https://files.pythonhosted.org/packages/47/3a/7d4cd7ed54be99973a0dc176032cba5cb1f258082c31fa6df35cff46acfc/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6ed74185b2db44f41ef35fd1617c5888e59792da9bbc9190d6c7300617182616", size = 227145, upload-time = "2026-04-02T09:25:55.904Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/98/3a45bf8247889cf28262ebd3d0872edff11565b2a1e3064ccb132db3fbb0/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:94e1885b270625a9a828c9793b4d52a64445299baa1fea5a173bf1d3dd9a1a5a", size = 218884, upload-time = "2026-04-02T09:25:57.074Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/80/2e8b7f8915ed5c9ef13aa828d82738e33888c485b65ebf744d615040c7ea/charset_normalizer-3.4.7-cp310-cp310-win32.whl", hash = "sha256:6785f414ae0f3c733c437e0f3929197934f526d19dfaa75e18fdb4f94c6fb374", size = 148343, upload-time = "2026-04-02T09:25:58.199Z" },
+    { url = "https://files.pythonhosted.org/packages/35/1b/3b8c8c77184af465ee9ad88b5aea46ea6b2e1f7b9dc9502891e37af21e30/charset_normalizer-3.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:6696b7688f54f5af4462118f0bfa7c1621eeb87154f77fa04b9295ce7a8f2943", size = 159174, upload-time = "2026-04-02T09:25:59.322Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c1/feb40dca40dbb21e0a908801782d9288c64fc8d8e562c2098e9994c8c21b/charset_normalizer-3.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:66671f93accb62ed07da56613636f3641f1a12c13046ce91ffc923721f23c008", size = 147805, upload-time = "2026-04-02T09:26:00.756Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/d7/b5b7020a0565c2e9fa8c09f4b5fa6232feb326b8c20081ccded47ea368fd/charset_normalizer-3.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7641bb8895e77f921102f72833904dcd9901df5d6d72a2ab8f31d04b7e51e4e7", size = 309705, upload-time = "2026-04-02T09:26:02.191Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/53/58c29116c340e5456724ecd2fff4196d236b98f3da97b404bc5e51ac3493/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:202389074300232baeb53ae2569a60901f7efadd4245cf3a3bf0617d60b439d7", size = 206419, upload-time = "2026-04-02T09:26:03.583Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/02/e8146dc6591a37a00e5144c63f29fb7c97a734ea8a111190783c0e60ab63/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:30b8d1d8c52a48c2c5690e152c169b673487a2a58de1ec7393196753063fcd5e", size = 227901, upload-time = "2026-04-02T09:26:04.738Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/73/77486c4cd58f1267bf17db420e930c9afa1b3be3fe8c8b8ebbebc9624359/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:532bc9bf33a68613fd7d65e4b1c71a6a38d7d42604ecf239c77392e9b4e8998c", size = 222742, upload-time = "2026-04-02T09:26:06.36Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/fa/f74eb381a7d94ded44739e9d94de18dc5edc9c17fb8c11f0a6890696c0a9/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fe249cb4651fd12605b7288b24751d8bfd46d35f12a20b1ba33dea122e690df", size = 214061, upload-time = "2026-04-02T09:26:08.347Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/92/42bd3cefcf7687253fb86694b45f37b733c97f59af3724f356fa92b8c344/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:65bcd23054beab4d166035cabbc868a09c1a49d1efe458fe8e4361215df40265", size = 199239, upload-time = "2026-04-02T09:26:09.823Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/3d/069e7184e2aa3b3cddc700e3dd267413dc259854adc3380421c805c6a17d/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:08e721811161356f97b4059a9ba7bafb23ea5ee2255402c42881c214e173c6b4", size = 210173, upload-time = "2026-04-02T09:26:10.953Z" },
+    { url = "https://files.pythonhosted.org/packages/62/51/9d56feb5f2e7074c46f93e0ebdbe61f0848ee246e2f0d89f8e20b89ebb8f/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e060d01aec0a910bdccb8be71faf34e7799ce36950f8294c8bf612cba65a2c9e", size = 209841, upload-time = "2026-04-02T09:26:12.142Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/59/893d8f99cc4c837dda1fe2f1139079703deb9f321aabcb032355de13b6c7/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:38c0109396c4cfc574d502df99742a45c72c08eff0a36158b6f04000043dbf38", size = 200304, upload-time = "2026-04-02T09:26:13.711Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/1d/ee6f3be3464247578d1ed5c46de545ccc3d3ff933695395c402c21fa6b77/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1c2a768fdd44ee4a9339a9b0b130049139b8ce3c01d2ce09f67f5a68048d477c", size = 229455, upload-time = "2026-04-02T09:26:14.941Z" },
+    { url = "https://files.pythonhosted.org/packages/54/bb/8fb0a946296ea96a488928bdce8ef99023998c48e4713af533e9bb98ef07/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:1a87ca9d5df6fe460483d9a5bbf2b18f620cbed41b432e2bddb686228282d10b", size = 210036, upload-time = "2026-04-02T09:26:16.478Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/bc/015b2387f913749f82afd4fcba07846d05b6d784dd16123cb66860e0237d/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d635aab80466bc95771bb78d5370e74d36d1fe31467b6b29b8b57b2a3cd7d22c", size = 224739, upload-time = "2026-04-02T09:26:17.751Z" },
+    { url = "https://files.pythonhosted.org/packages/17/ab/63133691f56baae417493cba6b7c641571a2130eb7bceba6773367ab9ec5/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ae196f021b5e7c78e918242d217db021ed2a6ace2bc6ae94c0fc596221c7f58d", size = 216277, upload-time = "2026-04-02T09:26:18.981Z" },
+    { url = "https://files.pythonhosted.org/packages/06/6d/3be70e827977f20db77c12a97e6a9f973631a45b8d186c084527e53e77a4/charset_normalizer-3.4.7-cp311-cp311-win32.whl", hash = "sha256:adb2597b428735679446b46c8badf467b4ca5f5056aae4d51a19f9570301b1ad", size = 147819, upload-time = "2026-04-02T09:26:20.295Z" },
+    { url = "https://files.pythonhosted.org/packages/20/d9/5f67790f06b735d7c7637171bbfd89882ad67201891b7275e51116ed8207/charset_normalizer-3.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:8e385e4267ab76874ae30db04c627faaaf0b509e1ccc11a95b3fc3e83f855c00", size = 159281, upload-time = "2026-04-02T09:26:21.74Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/83/6413f36c5a34afead88ce6f66684d943d91f233d76dd083798f9602b75ae/charset_normalizer-3.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:d4a48e5b3c2a489fae013b7589308a40146ee081f6f509e047e0e096084ceca1", size = 147843, upload-time = "2026-04-02T09:26:22.901Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" },
+    { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" },
+    { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" },
+    { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" },
+    { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" },
+    { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" },
+    { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" },
+    { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" },
+    { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" },
+    { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" },
+    { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" },
+    { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" },
+    { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" },
+    { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
+]
+
 [[package]]
 name = "click"
 version = "8.3.1"
@@ -383,6 +499,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1a/89/843b53614b47f97fe1abc13f9a86efa5ec9e275292c457af1d4a60dc80e0/cryptography-46.0.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6728c49e3b2c180ef26f8e9f0a883a2c585638db64cf265b49c9ba10652d430e", size = 3409955, upload-time = "2026-03-25T23:34:48.465Z" },
 ]
 
+[[package]]
+name = "docutils"
+version = "0.22.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/b6/03bb70946330e88ffec97aefd3ea75ba575cb2e762061e0e62a213befee8/docutils-0.22.4.tar.gz", hash = "sha256:4db53b1fde9abecbb74d91230d32ab626d94f6badfc575d6db9194a49df29968", size = 2291750, upload-time = "2025-12-18T19:00:26.443Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/10/5da547df7a391dcde17f59520a231527b8571e6f46fc8efb02ccb370ab12/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de", size = 633196, upload-time = "2025-12-18T19:00:18.077Z" },
+]
+
 [[package]]
 name = "exceptiongroup"
 version = "1.3.1"
@@ -441,6 +566,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
 ]
 
+[[package]]
+name = "id"
+version = "1.6.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/04/c2156091427636080787aac190019dc64096e56a23b7364d3c1764ee3a06/id-1.6.1.tar.gz", hash = "sha256:d0732d624fb46fd4e7bc4e5152f00214450953b9e772c182c1c22964def1a069", size = 18088, upload-time = "2026-02-04T16:19:41.26Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/77/de194443bf38daed9452139e960c632b0ef9f9a5dd9ce605fdf18ca9f1b1/id-1.6.1-py3-none-any.whl", hash = "sha256:f5ec41ed2629a508f5d0988eda142e190c9c6da971100612c4de9ad9f9b237ca", size = 14689, upload-time = "2026-02-04T16:19:40.051Z" },
+]
+
 [[package]]
 name = "idna"
 version = "3.11"
@@ -450,6 +587,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
 ]
 
+[[package]]
+name = "importlib-metadata"
+version = "9.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/3d/2d244233ac4f76e38533cfcb2991c9eb4c7bf688ae0a036d30725b8faafe/importlib_metadata-9.0.0-py3-none-any.whl", hash = "sha256:2d21d1cc5a017bd0559e36150c21c830ab1dc304dedd1b7ea85d20f45ef3edd7", size = 27789, upload-time = "2026-03-20T06:42:55.665Z" },
+]
+
 [[package]]
 name = "iniconfig"
 version = "2.3.0"
@@ -459,6 +608,51 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
 ]
 
+[[package]]
+name = "jaraco-classes"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "more-itertools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" },
+]
+
+[[package]]
+name = "jaraco-context"
+version = "6.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "backports-tarfile", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871, upload-time = "2026-03-20T22:13:32.808Z" },
+]
+
+[[package]]
+name = "jaraco-functools"
+version = "4.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "more-itertools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0f/27/056e0638a86749374d6f57d0b0db39f29509cce9313cf91bdc0ac4d91084/jaraco_functools-4.4.0.tar.gz", hash = "sha256:da21933b0417b89515562656547a77b4931f98176eb173644c0d35032a33d6bb", size = 19943, upload-time = "2025-12-21T09:29:43.6Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/c4/813bb09f0985cb21e959f21f2464169eca882656849adf727ac7bb7e1767/jaraco_functools-4.4.0-py3-none-any.whl", hash = "sha256:9eec1e36f45c818d9bf307c8948eb03b2b56cd44087b3cdc989abca1f20b9176", size = 10481, upload-time = "2025-12-21T09:29:42.27Z" },
+]
+
+[[package]]
+name = "jeepney"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" },
+]
+
 [[package]]
 name = "jsonschema"
 version = "4.26.0"
@@ -486,6 +680,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
 ]
 
+[[package]]
+name = "keyring"
+version = "25.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata", marker = "python_full_version < '3.12'" },
+    { name = "jaraco-classes" },
+    { name = "jaraco-context" },
+    { name = "jaraco-functools" },
+    { name = "jeepney", marker = "sys_platform == 'linux'" },
+    { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" },
+    { name = "secretstorage", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" },
+]
+
 [[package]]
 name = "librt"
 version = "0.8.1"
@@ -571,6 +783,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b2/c8/d148e041732d631fc76036f8b30fae4e77b027a1e95b7a84bb522481a940/librt-0.8.1-cp314-cp314t-win_arm64.whl", hash = "sha256:bf512a71a23504ed08103a13c941f763db13fb11177beb3d9244c98c29fb4a61", size = 48755, upload-time = "2026-02-17T16:12:47.943Z" },
 ]
 
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
 [[package]]
 name = "mcp"
 version = "1.26.0"
@@ -596,6 +820,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fd/d9/eaa1f80170d2b7c5ba23f3b59f766f3a0bb41155fbc32a69adfa1adaaef9/mcp-1.26.0-py3-none-any.whl", hash = "sha256:904a21c33c25aa98ddbeb47273033c435e595bbacfdb177f4bd87f6dceebe1ca", size = 233615, upload-time = "2026-01-24T19:40:30.652Z" },
 ]
 
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "more-itertools"
+version = "11.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/f7/139d22fef48ac78127d18e01d80cf1be40236ae489769d17f35c3d425293/more_itertools-11.0.2.tar.gz", hash = "sha256:392a9e1e362cbc106a2457d37cabf9b36e5e12efd4ebff1654630e76597df804", size = 144659, upload-time = "2026-04-09T15:01:33.297Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/98/6af411189d9413534c3eb691182bff1f5c6d44ed2f93f2edfe52a1bbceb8/more_itertools-11.0.2-py3-none-any.whl", hash = "sha256:6e35b35f818b01f691643c6c611bc0902f2e92b46c18fffa77ae1e7c46e912e4", size = 71939, upload-time = "2026-04-09T15:01:32.21Z" },
+]
+
 [[package]]
 name = "mypy"
 version = "1.19.1"
@@ -651,6 +893,40 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
 ]
 
+[[package]]
+name = "nh3"
+version = "0.3.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9c/5f/1d19bdc7d27238e37f3672cdc02cb77c56a4a86d140cd4f4f23c90df6e16/nh3-0.3.5.tar.gz", hash = "sha256:45855e14ff056064fec77133bfcf7cd691838168e5e17bbef075394954dc9dc8", size = 20743, upload-time = "2026-04-25T10:44:16.066Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/b0/8587ac42a9627ab88e7e221601f1dfccbf4db80b2a29222ea63266dc9abc/nh3-0.3.5-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:23a312224875f72cd16bde417f49071451877e29ef646a60e50fcb69407cc18a", size = 1420126, upload-time = "2026-04-25T10:43:39.834Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/1b/1dbc4d0c43f12e8c1784ede17eaee6f061d4fbe5505757c65c49b2ceab95/nh3-0.3.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:387abd011e81959d5a35151a11350a0795c6edeb53ebfa02d2e882dc01299263", size = 793943, upload-time = "2026-04-25T10:43:41.363Z" },
+    { url = "https://files.pythonhosted.org/packages/47/9f/d6758d7a14ee964bf439cc35ae4fa24a763a93399c8ef6f22bd11d532d29/nh3-0.3.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:48f45e3e914be93a596431aa143dedf1582557bf41a58153c296048d6e3798c9", size = 841150, upload-time = "2026-04-25T10:43:43.007Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/36/d5d1ae8374612c98f390e1ea7c610fa6c9716259a03bbf4d15b269f40073/nh3-0.3.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0a09f51806fd51b4fedbf9ea2b61fef388f19aef0d62fe51199d41648be14588", size = 1008415, upload-time = "2026-04-25T10:43:44.324Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8f/d13a9c3fd2d9c131a2a281737380e9379eb0f8c33fea24c2b923aaafbb15/nh3-0.3.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:c357f1d042c67f135a5e6babb2b0e3b9d9224ff4a3543240f597767b01384ffd", size = 1092706, upload-time = "2026-04-25T10:43:45.653Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/57/2f3add7f8680fcc896afa6a675cb2bab09982853ee8af40bad621f6b61c4/nh3-0.3.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:38748140bf76383ab7ce2dce0ad4cb663855d8fbc9098f7f3483673d09616a17", size = 1048346, upload-time = "2026-04-25T10:43:46.974Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c3/2f9e4ffa82863074d1361bfe949bc46393d91b3411579dfbbd090b24cac5/nh3-0.3.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:84bdeb082544fbcb77a12c034dd77d7da0556fdc0727b787eb6214b958c15e29", size = 1029038, upload-time = "2026-04-25T10:43:48.569Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/10/2804deb3f3315184c9cae41702e293c87524b5a21f766b07d7fe3ffbcfbb/nh3-0.3.5-cp314-cp314t-win32.whl", hash = "sha256:c3aae321f67ae66cff2a627115f106a377d4475d10b0e13d97959a13486b9a88", size = 603263, upload-time = "2026-04-25T10:43:49.851Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/a2/f6685248b49f7548fc9a8c335ab3a52f68610b72e8a61576447151e4e2e6/nh3-0.3.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c88605d8d468f7fc1b31e06129bc91d6c96f6c621776c9b504a0da9beac9df5f", size = 616866, upload-time = "2026-04-25T10:43:51.005Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/b6/d8c9018635d4acfefde6b68470daa510eed715a350cbaa2f928ba0609f81/nh3-0.3.5-cp314-cp314t-win_arm64.whl", hash = "sha256:72c5bdedec27fa33de6a5326346ea8aa3fe54f6ac294d54c4b204fb66a9f1e79", size = 602566, upload-time = "2026-04-25T10:43:52.283Z" },
+    { url = "https://files.pythonhosted.org/packages/85/30/d162e99746a2fb1d98bb0ef23af3e201b156cf09f7de867c7390c8fe1c06/nh3-0.3.5-cp38-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:3bb854485c9b33e5bb143ff3e49e577073bc6bc320f0ff8fc316dd89c0d3c101", size = 1442393, upload-time = "2026-04-25T10:43:53.556Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8c/072120d506978ab053e1732d0efa7c86cb478fee0ee098fda0ac0d31cb34/nh3-0.3.5-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50d401ab2d8e86d59e2126e3ab2a2f45840c405842b626d9a51624b3a33b6878", size = 837722, upload-time = "2026-04-25T10:43:55.073Z" },
+    { url = "https://files.pythonhosted.org/packages/52/86/d4e06e28c5ad1c4b065f89737d02631bd49f1660b6ebcf17a87ffcd201da/nh3-0.3.5-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:acfd354e61accbe4c74f8017c6e397a776916dfe47c48643cf7fd84ade826f93", size = 822872, upload-time = "2026-04-25T10:43:56.581Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/62/50659255213f241ec5797ae7427464c969397373e83b3659372b341ae869/nh3-0.3.5-cp38-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:52d877980d7ca01dc3baf3936bf844828bc6f332962227a684ed79c18cce14c3", size = 1100031, upload-time = "2026-04-25T10:43:58.098Z" },
+    { url = "https://files.pythonhosted.org/packages/00/7a/a12ae77593b2fcf3be25df7bc1c01967d0de448bdb4b6c7ec80fe4f5a74f/nh3-0.3.5-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:207c01801d3e9bb8ec08f08689346bdd30ce15b8bf60013a925d08b5388962a4", size = 1057669, upload-time = "2026-04-25T10:43:59.328Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/71/5647dc04c0233192a3956fc91708822b21403a06508cacf78083c68e7bf0/nh3-0.3.5-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea232933394d1d58bf7c4bb348dc4660eae6604e1ae81cd2ba6d9ed80d390f3b", size = 914795, upload-time = "2026-04-25T10:44:00.52Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/0e/bf298920729f216adcb002acf7ea01b90842603d2e4e2ce9b900d9ee8fab/nh3-0.3.5-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fe3a787dc76b50de6bee54ef242f26c41dfe47654428e3e94f0fae5bb6dd2cc1", size = 806976, upload-time = "2026-04-25T10:44:01.743Z" },
+    { url = "https://files.pythonhosted.org/packages/85/01/26761e1dc2b848e65a62c19e5d39ad446283287cd4afddc89f364ab86bc9/nh3-0.3.5-cp38-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:488928988caad25ba14b1eb5bc74e25e21f3b5e40341d956f3ce4a8bc19460dc", size = 834904, upload-time = "2026-04-25T10:44:03.454Z" },
+    { url = "https://files.pythonhosted.org/packages/33/53/0766113e679540ac1edc1b82b1295aecd321eeb75d6fead70109a838b6ee/nh3-0.3.5-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2c069570b06aa848457713ad7af4a9905691291548c4466a9ad78ee95808382b", size = 857159, upload-time = "2026-04-25T10:44:05.003Z" },
+    { url = "https://files.pythonhosted.org/packages/58/36/734d353dfaf292fed574b8b3092f0ef79dc6404f3879f7faaa61a4701fad/nh3-0.3.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:eeedc90ed8c42c327e8e10e621ccfa314fc6cce35d5929f4297ff1cdb89667c4", size = 1018600, upload-time = "2026-04-25T10:44:06.18Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/aa/d9c59c1b49669fcb7bababa55df82385f029ad5c2651f583c3a1141cfdd1/nh3-0.3.5-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:de8e8621853b6470fe928c684ee0d3f39ea8086cebafe4c416486488dea7b68d", size = 1103530, upload-time = "2026-04-25T10:44:07.68Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b0/cdd210bfb8d9d43fb02fc3c868336b9955934d8e15e66eb1d15a147b8af0/nh3-0.3.5-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:6ea58cc44d274c643b83547ca9654a0b1a817609b160601356f76a2b744c49ad", size = 1061754, upload-time = "2026-04-25T10:44:09.362Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/cb/7a39e72e668c8445bdd95e494b3e21cfdddc68329be8ea3522c8befb46c4/nh3-0.3.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e49c9b564e6bcb03ecd2f057213df9a0de15a95812ac9db9600b590db23d3ae9", size = 1040938, upload-time = "2026-04-25T10:44:10.775Z" },
+    { url = "https://files.pythonhosted.org/packages/af/4c/fc2f9ed208a3801a319f59b5fea03cdc20cf3bd8af14be930d3a8de01224/nh3-0.3.5-cp38-abi3-win32.whl", hash = "sha256:559e4c73b689e9a7aa97ac9760b1bc488038d7c1a575aa4ab5a0e19ee9630c0f", size = 611445, upload-time = "2026-04-25T10:44:12.317Z" },
+    { url = "https://files.pythonhosted.org/packages/db/1a/e4c9b5e2ae13e6092c9ec16d8ca30646cb01fcdea245f36c5b08fd21fbd5/nh3-0.3.5-cp38-abi3-win_amd64.whl", hash = "sha256:45e6a65dc88a300a2e3502cb9c8e6d1d6b831d6fba7470643333609c6aab1f30", size = 626502, upload-time = "2026-04-25T10:44:13.682Z" },
+    { url = "https://files.pythonhosted.org/packages/80/7c/19cd0671d1ba2762fb388fc149697d20d0568ccfeef833b11280a619e526/nh3-0.3.5-cp38-abi3-win_arm64.whl", hash = "sha256:8f85285700a18e9f3fc5bff41fe573fa84f81542ef13b48a89f9fecca0474d3b", size = 611069, upload-time = "2026-04-25T10:44:14.934Z" },
+]
+
 [[package]]
 name = "packaging"
 version = "26.0"
@@ -974,6 +1250,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" },
 ]
 
+[[package]]
+name = "pywin32-ctypes"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" },
+]
+
 [[package]]
 name = "pyyaml"
 version = "6.0.3"
@@ -1038,6 +1323,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
+[[package]]
+name = "readme-renderer"
+version = "44.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "docutils" },
+    { name = "nh3" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5a/a9/104ec9234c8448c4379768221ea6df01260cd6c2ce13182d4eac531c8342/readme_renderer-44.0.tar.gz", hash = "sha256:8712034eabbfa6805cacf1402b4eeb2a73028f72d1166d6f5cb7f9c047c5d1e1", size = 32056, upload-time = "2024-07-08T15:00:57.805Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/67/921ec3024056483db83953ae8e48079ad62b92db7880013ca77632921dd0/readme_renderer-44.0-py3-none-any.whl", hash = "sha256:2fbca89b81a08526aadf1357a8c2ae889ec05fb03f5da67f9769c9a592166151", size = 13310, upload-time = "2024-07-08T15:00:56.577Z" },
+]
+
 [[package]]
 name = "referencing"
 version = "0.37.0"
@@ -1052,6 +1351,55 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
 ]
 
+[[package]]
+name = "requests"
+version = "2.33.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" },
+]
+
+[[package]]
+name = "requests-toolbelt"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" },
+]
+
+[[package]]
+name = "rfc3986"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/40/1520d68bfa07ab5a6f065a186815fb6610c86fe957bc065754e47f7b0840/rfc3986-2.0.0.tar.gz", hash = "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c", size = 49026, upload-time = "2022-01-10T00:52:30.832Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/9a/9afaade874b2fa6c752c36f1548f718b5b83af81ed9b76628329dab81c1b/rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd", size = 31326, upload-time = "2022-01-10T00:52:29.594Z" },
+]
+
+[[package]]
+name = "rich"
+version = "15.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
+]
+
 [[package]]
 name = "rpds-py"
 version = "0.30.0"
@@ -1199,6 +1547,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/15/e2/77be4fff062fa78d9b2a4dea85d14785dac5f1d0c1fb58ed52331f0ebe28/ruff-0.15.8-py3-none-win_arm64.whl", hash = "sha256:cf891fa8e3bb430c0e7fac93851a5978fc99c8fa2c053b57b118972866f8e5f2", size = 11048175, upload-time = "2026-03-26T18:40:01.06Z" },
 ]
 
+[[package]]
+name = "secretstorage"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cryptography" },
+    { name = "jeepney" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" },
+]
+
 [[package]]
 name = "sse-starlette"
 version = "3.3.4"
@@ -1279,6 +1640,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
 ]
 
+[[package]]
+name = "twine"
+version = "6.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "id" },
+    { name = "keyring", marker = "platform_machine != 'ppc64le' and platform_machine != 's390x'" },
+    { name = "packaging" },
+    { name = "readme-renderer" },
+    { name = "requests" },
+    { name = "requests-toolbelt" },
+    { name = "rfc3986" },
+    { name = "rich" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e0/a8/949edebe3a82774c1ec34f637f5dd82d1cf22c25e963b7d63771083bbee5/twine-6.2.0.tar.gz", hash = "sha256:e5ed0d2fd70c9959770dce51c8f39c8945c574e18173a7b81802dab51b4b75cf", size = 172262, upload-time = "2025-09-04T15:43:17.255Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/7a/882d99539b19b1490cac5d77c67338d126e4122c8276bf640e411650c830/twine-6.2.0-py3-none-any.whl", hash = "sha256:418ebf08ccda9a8caaebe414433b0ba5e25eb5e4a927667122fbe8f829f985d8", size = 42727, upload-time = "2025-09-04T15:43:15.994Z" },
+]
+
 [[package]]
 name = "types-psutil"
 version = "7.2.2.20260402"
@@ -1327,6 +1708,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]
 
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
 [[package]]
 name = "uvicorn"
 version = "0.42.0"
@@ -1340,3 +1730,12 @@ sdist = { url = "https://files.pythonhosted.org/packages/e3/ad/4a96c425be6fb67e0
 wheels = [
     { url = "https://files.pythonhosted.org/packages/0a/89/f8827ccff89c1586027a105e5630ff6139a64da2515e24dafe860bd9ae4d/uvicorn-0.42.0-py3-none-any.whl", hash = "sha256:96c30f5c7abe6f74ae8900a70e92b85ad6613b745d4879eb9b16ccad15645359", size = 68830, upload-time = "2026-03-16T06:19:48.325Z" },
 ]
+
+[[package]]
+name = "zipp"
+version = "3.23.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964ded15ab726fad40f25fd3d788fd741cc1c5a17d78ee8/zipp-3.23.1.tar.gz", hash = "sha256:32120e378d32cd9714ad503c1d024619063ec28aad2248dc6672ad13edfa5110", size = 25965, upload-time = "2026-04-13T23:21:46.6Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", hash = "sha256:0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc", size = 10378, upload-time = "2026-04-13T23:21:45.386Z" },
+]

From 3baac631d3703462e522da3f6ce0c1631fec1255 Mon Sep 17 00:00:00 2001
From: SummerOneTwo <89140025+SummerOneTwo@users.noreply.github.com>
Date: Wed, 29 Apr 2026 03:22:08 +0800
Subject: [PATCH 2/4] fix ci failures for new cleanup tool

Made-with: Cursor
---
 src/autocode_mcp/tools/problem.py | 10 ++++++----
 tests/test_e2e_mcp.py             |  5 +++--
 tests/test_tools/test_problem.py  | 25 +++++++++++++++++--------
 3 files changed, 26 insertions(+), 14 deletions(-)

diff --git a/src/autocode_mcp/tools/problem.py b/src/autocode_mcp/tools/problem.py
index f928779..6d7fcf0 100644
--- a/src/autocode_mcp/tools/problem.py
+++ b/src/autocode_mcp/tools/problem.py
@@ -12,7 +12,7 @@
 import time
 from dataclasses import dataclass
 
-from ..utils.compiler import run_binary, run_binary_with_args
+from ..utils.compiler import RunResult, run_binary, run_binary_with_args
 from ..utils.platform import get_exe_extension
 from .base import Tool, ToolResult
 
@@ -733,8 +733,8 @@ async def _run_with_retry(
         args: list[str],
         timeout: int,
         active_pids: set[int],
-    ) -> object:
-        last_result = None
+    ) -> RunResult:
+        last_result: RunResult | None = None
         for attempt in range(3):
             started_pid: int | None = None
             cancelled = False
@@ -761,7 +761,9 @@ def _on_start(pid: int) -> None:
             if not getattr(last_result, "error", None):
                 return last_result
             await asyncio.sleep(0.1 * (2**attempt))
-        return last_result
+        if last_result is not None:
+            return last_result
+        return RunResult(success=False, error="Generator execution returned no result")
 
     def _save_state(
         self,
diff --git a/tests/test_e2e_mcp.py b/tests/test_e2e_mcp.py
index 6207197..a9dcaaf 100644
--- a/tests/test_e2e_mcp.py
+++ b/tests/test_e2e_mcp.py
@@ -126,7 +126,7 @@ async def test_mcp_list_tools(mcp_client: MCPClient):
 
     tools = await mcp_client.list_tools()
 
-    assert len(tools) == 17
+    assert len(tools) == 18
 
     tool_names = {t["name"] for t in tools}
     expected_tools = {
@@ -140,6 +140,7 @@ async def test_mcp_list_tools(mcp_client: MCPClient):
         "stress_test_run",
         "problem_create",
         "problem_generate_tests",
+        "problem_cleanup_processes",
         "problem_validate",
     }
     assert expected_tools.issubset(tool_names)
@@ -273,7 +274,7 @@ async def test_packaged_console_script_list_tools(packaged_mcp_client: MCPClient
 
     tools = await packaged_mcp_client.list_tools()
 
-    assert len(tools) == 17
+    assert len(tools) == 18
     tool_names = {t["name"] for t in tools}
     assert "solution_build" in tool_names
     assert "validator_build" in tool_names
diff --git a/tests/test_tools/test_problem.py b/tests/test_tools/test_problem.py
index 1e906b5..e13ec83 100644
--- a/tests/test_tools/test_problem.py
+++ b/tests/test_tools/test_problem.py
@@ -697,7 +697,10 @@ async def test_problem_cleanup_processes_does_not_global_kill_without_tracked_pi
     with tempfile.TemporaryDirectory() as tmpdir:
         result = await tool.execute(problem_dir=tmpdir, kill_all_generators=True)
         assert result.success
-        assert "warning" in result.data
+        if os.name == "nt":
+            assert "warning" in result.data
+        else:
+            assert result.data.get("message") == "Cleanup finished"
 
 
 @pytest.mark.asyncio
@@ -726,8 +729,11 @@ async def fake_create_subprocess_exec(*args, **kwargs):
             json.dump({"active_pids": [12345, 23456]}, f)
         result = await tool.execute(problem_dir=tmpdir, kill_all_generators=True)
         assert result.success
-        assert result.data.get("killed_pids") == [12345, 23456]
-        assert len(called_cmds) == 2
+        if os.name == "nt":
+            assert result.data.get("killed_pids") == [12345, 23456]
+            assert len(called_cmds) == 2
+        else:
+            assert result.data.get("removed_files") == []
 
 
 @pytest.mark.asyncio
@@ -759,11 +765,14 @@ async def fake_create_subprocess_exec(*args, **kwargs):
 
         result = await tool.execute(problem_dir=tmpdir, kill_all_generators=True)
         assert result.success
-        assert result.data.get("killed_pids") == [111]
-        assert os.path.exists(state_path)
-        with open(state_path, encoding="utf-8") as f:
-            state = json.load(f)
-        assert state.get("active_pids") == [222]
+        if os.name == "nt":
+            assert result.data.get("killed_pids") == [111]
+            assert os.path.exists(state_path)
+            with open(state_path, encoding="utf-8") as f:
+                state = json.load(f)
+            assert state.get("active_pids") == [222]
+        else:
+            assert result.data.get("removed_files") == []
 
 
 @pytest.mark.asyncio

From 4e89ec4293ec67e00dd292842edf3e1dc172bb8b Mon Sep 17 00:00:00 2001
From: SummerOneTwo <89140025+SummerOneTwo@users.noreply.github.com>
Date: Wed, 29 Apr 2026 03:33:10 +0800
Subject: [PATCH 3/4] fix post-review robustness for test generation flow

Tighten answer_ext normalization and retry semantics, clear stale generated outputs before final writes, and make cleanup/semantic checks more resilient across platforms and generator branch styles.

Made-with: Cursor
---
 src/autocode_mcp/tools/generator.py   | 27 ++++++++++++++++++++-------
 src/autocode_mcp/tools/problem.py     | 17 +++++++++++++++--
 src/autocode_mcp/tools/test_verify.py | 27 ++++++++++++++++++++++-----
 3 files changed, 57 insertions(+), 14 deletions(-)

diff --git a/src/autocode_mcp/tools/generator.py b/src/autocode_mcp/tools/generator.py
index db2dc59..87cdd3a 100644
--- a/src/autocode_mcp/tools/generator.py
+++ b/src/autocode_mcp/tools/generator.py
@@ -142,18 +142,19 @@ async def execute(
         )
 
     def _check_type34_semantics(self, code: str) -> dict:
-        has_type3 = bool(re.search(r"type\s*==\s*3", code))
-        has_type4 = bool(re.search(r"type\s*==\s*4", code))
+        type3_blocks = self._extract_type_branch_snippets(code, 3)
+        type4_blocks = self._extract_type_branch_snippets(code, 4)
+        has_type3 = bool(type3_blocks)
+        has_type4 = bool(type4_blocks)
         if not has_type3 or not has_type4:
             return {
                 "enabled": True,
-                "passed": False,
-                "reason": "generator lacks explicit type==3/type==4 branches",
-                "hint": "需要给 type=3/type=4 设计不同逻辑，避免仅靠参数放大",
+                "passed": True,
+                "advisory": True,
+                "reason": "semantic check could not reliably detect both type=3/type=4 branches",
+                "hint": "请人工确认 type=3/type=4 分支存在且有实质差异",
             }
 
-        type3_blocks = re.findall(r"type\s*==\s*3[\s\S]{0,240}", code)
-        type4_blocks = re.findall(r"type\s*==\s*4[\s\S]{0,240}", code)
         norm3 = " ".join(type3_blocks).replace(" ", "")
         norm4 = " ".join(type4_blocks).replace(" ", "")
         output_lines = [line.strip() for line in code.splitlines() if "cout" in line or "printf" in line]
@@ -166,6 +167,18 @@ def _check_type34_semantics(self, code: str) -> dict:
             "hint": "为 type=4 增加针对性卡法，而不仅是 n_max/t_max 取最大值",
         }
 
+    def _extract_type_branch_snippets(self, code: str, type_value: int) -> list[str]:
+        patterns = [
+            rf"type\s*==\s*{type_value}\b",
+            rf"\b{type_value}\s*==\s*type\b",
+            rf"case\s+{type_value}\s*:",
+        ]
+        snippets: list[str] = []
+        for pattern in patterns:
+            for match in re.finditer(pattern, code):
+                snippets.append(code[match.start(): match.start() + 240])
+        return snippets
+
 
 class GeneratorRunTool(Tool):
     """运行多策略数据生成器。"""
diff --git a/src/autocode_mcp/tools/problem.py b/src/autocode_mcp/tools/problem.py
index 6d7fcf0..9066c20 100644
--- a/src/autocode_mcp/tools/problem.py
+++ b/src/autocode_mcp/tools/problem.py
@@ -563,6 +563,11 @@ async def execute(
         else:
             final_tests = candidates
 
+        # 最终写盘前清理历史生成产物，防止 resume 场景残留旧编号样例。
+        clear_before_write_error = self._clear_generated_tests(tests_dir, normalized_answer_ext)
+        if clear_before_write_error:
+            return clear_before_write_error
+
         # 写入文件
         generated_tests = []
         test_manifest: list[dict[str, str | int]] = []
@@ -721,6 +726,8 @@ def _normalize_answer_ext(self, answer_ext: str) -> tuple[str | None, ToolResult
             return None, ToolResult.fail("answer_ext cannot be empty")
         if not ext.startswith("."):
             ext = f".{ext}"
+        if not any(ch != "." for ch in ext[1:]):
+            return None, ToolResult.fail("answer_ext must contain non-dot characters")
         if any(ch in ext for ch in ('/', '\\', ':', '*', '?', '"', "<", ">", "|")):
             return None, ToolResult.fail("answer_ext contains illegal characters")
         if ext == ".in":
@@ -758,7 +765,7 @@ def _on_start(pid: int) -> None:
                 # 取消路径保留 PID 到状态文件，供 cleanup 精准回收。
                 if started_pid is not None and not cancelled:
                     active_pids.discard(started_pid)
-            if not getattr(last_result, "error", None):
+            if last_result.success:
                 return last_result
             await asyncio.sleep(0.1 * (2**attempt))
         if last_result is not None:
@@ -1076,7 +1083,13 @@ async def execute(self, problem_dir: str, kill_all_generators: bool = False) ->
         if os.path.exists(state_path) and not pids:
             os.remove(state_path)
             removed_files.append(state_path)
-        return ToolResult.ok(removed_files=removed_files, message="Cleanup finished")
+        return ToolResult.ok(
+            removed_files=removed_files,
+            killed_pids=[],
+            failed_pids=[],
+            warning="PID termination is only supported on Windows" if kill_all_generators and os.name != "nt" else "",
+            message="Cleanup finished",
+        )
 
     def _load_cleanup_state(self, state_path: str) -> dict | None:
         if not os.path.exists(state_path):
diff --git a/src/autocode_mcp/tools/test_verify.py b/src/autocode_mcp/tools/test_verify.py
index 19a773f..e1d82e5 100644
--- a/src/autocode_mcp/tools/test_verify.py
+++ b/src/autocode_mcp/tools/test_verify.py
@@ -493,16 +493,33 @@ def _check_limit_semantics(self, tests_dir: str) -> dict:
         }
 
     def _resolve_answer_ext(self, tests_dir: str, answer_ext: str | None) -> str:
-        if answer_ext:
-            return answer_ext if answer_ext.startswith(".") else f".{answer_ext}"
+        normalized = self._normalize_answer_ext(answer_ext)
+        if normalized:
+            return normalized
         manifest_path = os.path.join(tests_dir, _TEST_MANIFEST_FILENAME)
         if os.path.exists(manifest_path):
             try:
                 with open(manifest_path, encoding="utf-8") as f:
                     manifest = json.load(f)
-                ext = manifest.get("answer_ext")
-                if isinstance(ext, str) and ext:
-                    return ext if ext.startswith(".") else f".{ext}"
+                ext = self._normalize_answer_ext(manifest.get("answer_ext"))
+                if ext:
+                    return ext
             except (json.JSONDecodeError, OSError):
                 pass
         return ".ans"
+
+    def _normalize_answer_ext(self, answer_ext: str | None) -> str | None:
+        if not isinstance(answer_ext, str):
+            return None
+        ext = answer_ext.strip()
+        if not ext:
+            return None
+        if not ext.startswith("."):
+            ext = f".{ext}"
+        if not any(ch != "." for ch in ext[1:]):
+            return None
+        if any(ch in ext for ch in ('/', '\\', ':', '*', '?', '"', "<", ">", "|")):
+            return None
+        if ext == ".in":
+            return None
+        return ext

From 096a0f7b8afadc58102cd3a5948ba1cec525950e Mon Sep 17 00:00:00 2001
From: SummerOneTwo <89140025+SummerOneTwo@users.noreply.github.com>
Date: Wed, 29 Apr 2026 11:54:23 +0800
Subject: [PATCH 4/4] fix cleanup checkpoint safety and polygon answer-ext
 sanitization

Preserve checkpoint metadata when cleaning tracked generator PIDs, add POSIX PID termination support, and sanitize/escape manifest-derived answer extensions in Polygon XML output.

Made-with: Cursor
---
 src/autocode_mcp/tools/problem.py  | 109 +++++++++++++++++------------
 src/autocode_mcp/utils/compiler.py |   3 +-
 src/autocode_mcp/utils/win_job.py  |   6 +-
 tests/test_tools/test_problem.py   |  70 ++++++++++++++++++
 4 files changed, 142 insertions(+), 46 deletions(-)

diff --git a/src/autocode_mcp/tools/problem.py b/src/autocode_mcp/tools/problem.py
index 9066c20..bebef23 100644
--- a/src/autocode_mcp/tools/problem.py
+++ b/src/autocode_mcp/tools/problem.py
@@ -9,8 +9,10 @@
 import json
 import os
 import shutil
+import signal
 import time
 from dataclasses import dataclass
+from xml.sax.saxutils import escape
 
 from ..utils.compiler import RunResult, run_binary, run_binary_with_args
 from ..utils.platform import get_exe_extension
@@ -31,6 +33,22 @@ class CandidateTest:
 _LIMIT_STRATEGY_TYPES = frozenset({"3", "4"})
 _TEST_MANIFEST_FILENAME = ".autocode_tests_manifest.json"
 _GENERATE_STATE_FILENAME = ".autocode_generate_state.json"
+_POSIX_KILL_SIGNAL = getattr(signal, "SIGKILL", signal.SIGTERM)
+
+
+def _normalize_answer_ext_value(answer_ext: str | None) -> str | None:
+    ext = (answer_ext or "").strip()
+    if not ext:
+        return None
+    if not ext.startswith("."):
+        ext = f".{ext}"
+    if not any(ch != "." for ch in ext[1:]):
+        return None
+    if any(ch in ext for ch in ('/', '\\', ':', '*', '?', '"', "<", ">", "|", "&")):
+        return None
+    if ext == ".in":
+        return None
+    return ext
 
 
 class ProblemCreateTool(Tool):
@@ -721,17 +739,9 @@ def _clear_generated_tests(self, tests_dir: str, answer_ext: str = ".ans") -> To
         return None
 
     def _normalize_answer_ext(self, answer_ext: str) -> tuple[str | None, ToolResult | None]:
-        ext = (answer_ext or ".ans").strip()
+        ext = _normalize_answer_ext_value(answer_ext or ".ans")
         if not ext:
-            return None, ToolResult.fail("answer_ext cannot be empty")
-        if not ext.startswith("."):
-            ext = f".{ext}"
-        if not any(ch != "." for ch in ext[1:]):
-            return None, ToolResult.fail("answer_ext must contain non-dot characters")
-        if any(ch in ext for ch in ('/', '\\', ':', '*', '?', '"', "<", ">", "|")):
-            return None, ToolResult.fail("answer_ext contains illegal characters")
-        if ext == ".in":
-            return None, ToolResult.fail("answer_ext cannot be .in")
+            return None, ToolResult.fail("invalid answer_ext")
         return ext, None
 
     async def _run_with_retry(
@@ -1038,38 +1048,48 @@ async def execute(self, problem_dir: str, kill_all_generators: bool = False) ->
         pids = state.get("active_pids", []) if isinstance(state, dict) else []
         if not isinstance(pids, list):
             pids = []
-        if kill_all_generators and os.name == "nt":
+        if kill_all_generators:
             try:
                 killed: list[int] = []
                 failed: list[dict[str, str | int]] = []
                 for pid in pids:
                     if not isinstance(pid, int) or pid <= 0:
                         continue
-                    proc = await asyncio.create_subprocess_exec(
-                        "taskkill",
-                        "/PID",
-                        str(pid),
-                        "/F",
-                        stdout=asyncio.subprocess.PIPE,
-                        stderr=asyncio.subprocess.PIPE,
-                    )
-                    stdout, stderr = await proc.communicate()
-                    if proc.returncode == 0:
-                        killed.append(pid)
-                    else:
-                        failed.append(
-                            {
-                                "pid": pid,
-                                "stdout": stdout.decode("utf-8", errors="replace"),
-                                "stderr": stderr.decode("utf-8", errors="replace"),
-                            }
+                    if os.name == "nt":
+                        proc = await asyncio.create_subprocess_exec(
+                            "taskkill",
+                            "/PID",
+                            str(pid),
+                            "/F",
+                            stdout=asyncio.subprocess.PIPE,
+                            stderr=asyncio.subprocess.PIPE,
                         )
+                        stdout, stderr = await proc.communicate()
+                        if proc.returncode == 0:
+                            killed.append(pid)
+                        else:
+                            failed.append(
+                                {
+                                    "pid": pid,
+                                    "stdout": stdout.decode("utf-8", errors="replace"),
+                                    "stderr": stderr.decode("utf-8", errors="replace"),
+                                }
+                            )
+                    else:
+                        try:
+                            os.kill(pid, _POSIX_KILL_SIGNAL)
+                            killed.append(pid)
+                        except OSError as exc:
+                            failed.append(
+                                {
+                                    "pid": pid,
+                                    "stdout": "",
+                                    "stderr": str(exc),
+                                }
+                            )
                 # 仅移除已成功清理的 PID；失败 PID 保留，支持后续重试。
                 remaining_pids = [pid for pid in pids if isinstance(pid, int) and pid not in killed]
                 self._write_cleanup_state(state_path, remaining_pids)
-                if not remaining_pids and os.path.exists(state_path):
-                    os.remove(state_path)
-                    removed_files.append(state_path)
                 return ToolResult.ok(
                     removed_files=removed_files,
                     killed_pids=killed,
@@ -1079,15 +1099,12 @@ async def execute(self, problem_dir: str, kill_all_generators: bool = False) ->
                 )
             except Exception as exc:
                 return ToolResult.fail(f"cleanup failed: {exc}", removed_files=removed_files)
-        # 非 Windows 或未请求 kill：仅在无 PID 时删除空状态文件。
-        if os.path.exists(state_path) and not pids:
-            os.remove(state_path)
-            removed_files.append(state_path)
+        # 未请求 kill：不删除 checkpoint，仅返回状态。
         return ToolResult.ok(
             removed_files=removed_files,
             killed_pids=[],
             failed_pids=[],
-            warning="PID termination is only supported on Windows" if kill_all_generators and os.name != "nt" else "",
+            warning="",
             message="Cleanup finished",
         )
 
@@ -1105,8 +1122,12 @@ def _load_cleanup_state(self, state_path: str) -> dict | None:
 
     def _write_cleanup_state(self, state_path: str, remaining_pids: list[int]) -> None:
         os.makedirs(os.path.dirname(state_path), exist_ok=True)
+        state = self._load_cleanup_state(state_path) or {}
+        if not isinstance(state, dict):
+            state = {}
+        state["active_pids"] = remaining_pids
         with open(state_path, "w", encoding="utf-8") as f:
-            json.dump({"active_pids": remaining_pids}, f, ensure_ascii=False, indent=2)
+            json.dump(state, f, ensure_ascii=False, indent=2)
 
 
 class ProblemPackPolygonTool(Tool):
@@ -1219,9 +1240,7 @@ async def execute(
                     try:
                         with open(manifest_path, encoding="utf-8") as mf:
                             manifest = json.load(mf)
-                        answer_ext = str(manifest.get("answer_ext", ".ans"))
-                        if not answer_ext.startswith("."):
-                            answer_ext = f".{answer_ext}"
+                        answer_ext = _normalize_answer_ext_value(str(manifest.get("answer_ext", ".ans"))) or ".ans"
                     except (OSError, json.JSONDecodeError):
                         answer_ext = ".ans"
             else:
@@ -1229,10 +1248,12 @@ async def execute(
                 answer_ext = ".ans"
 
             problem_name = os.path.basename(problem_dir)
+            xml_problem_name = escape(problem_name, {'"': "&quot;"})
+            xml_answer_ext = escape(answer_ext, {'"': "&quot;"})
             xml_content = f'''<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<problem revision="1" short-name="{problem_name}">
+<problem revision="1" short-name="{xml_problem_name}">
     <names>
-        <name language="chinese" value="{problem_name}"/>
+        <name language="chinese" value="{xml_problem_name}"/>
     </names>
     <statements>
         <statement charset="UTF-8" language="chinese" mathjax="true" path="statements/README.md" type="application/x-tex"/>
@@ -1243,7 +1264,7 @@ async def execute(
             <memory-limit>{memory_limit_bytes}</memory-limit>
             <test-count>{actual_test_count}</test-count>
             <input-path-pattern>tests/%02d.in</input-path-pattern>
-            <answer-path-pattern>tests/%02d{answer_ext}</answer-path-pattern>
+            <answer-path-pattern>tests/%02d{xml_answer_ext}</answer-path-pattern>
         </testset>
     </judging>
     <files>
diff --git a/src/autocode_mcp/utils/compiler.py b/src/autocode_mcp/utils/compiler.py
index 2a65ee9..c68d95d 100644
--- a/src/autocode_mcp/utils/compiler.py
+++ b/src/autocode_mcp/utils/compiler.py
@@ -360,7 +360,8 @@ async def _run_process(
 
         elapsed_ms = int((time.time() - start_time) * 1000)
 
-        # 正常完成后只关闭 Job Handle
+        # 正常完成后关闭 Job Handle；若 Job 配置了 KILL_ON_JOB_CLOSE，
+        # 关闭时仍可能终止 Job 中尚未退出的子进程。
         if job:
             job.close()
 
diff --git a/src/autocode_mcp/utils/win_job.py b/src/autocode_mcp/utils/win_job.py
index 70e2e51..736d086 100644
--- a/src/autocode_mcp/utils/win_job.py
+++ b/src/autocode_mcp/utils/win_job.py
@@ -141,7 +141,11 @@ def terminate(self) -> None:
             self.job_handle = None
 
     def close(self) -> None:
-        """关闭 Job Object 句柄（不主动终止进程）。"""
+        """关闭 Job Object 句柄。
+
+        注意：当前 Job 使用了 KILL_ON_JOB_CLOSE，关闭最后一个句柄时
+        仍可能终止 Job 中尚未退出的进程。
+        """
         if self.job_handle is not None and self.job_handle != 0:
             win32api.CloseHandle(self.job_handle)
             self.job_handle = None
diff --git a/tests/test_tools/test_problem.py b/tests/test_tools/test_problem.py
index e13ec83..e019565 100644
--- a/tests/test_tools/test_problem.py
+++ b/tests/test_tools/test_problem.py
@@ -775,6 +775,52 @@ async def fake_create_subprocess_exec(*args, **kwargs):
             assert result.data.get("removed_files") == []
 
 
+@pytest.mark.asyncio
+async def test_problem_cleanup_processes_preserves_checkpoint_fields(monkeypatch):
+    """cleanup 更新 active_pids 时不应覆盖 checkpoint 其他字段。"""
+    tool = ProblemCleanupProcessesTool()
+
+    class _FakeProc:
+        returncode = 0
+
+        async def communicate(self):
+            return b"ok", b""
+
+    async def fake_create_subprocess_exec(*args, **kwargs):
+        return _FakeProc()
+
+    monkeypatch.setattr("autocode_mcp.tools.problem.asyncio.create_subprocess_exec", fake_create_subprocess_exec)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tests_dir = os.path.join(tmpdir, "tests")
+        os.makedirs(tests_dir, exist_ok=True)
+        state_path = os.path.join(tests_dir, ".autocode_generate_state.json")
+        with open(state_path, "w", encoding="utf-8") as f:
+            json.dump(
+                {
+                    "phase": "partial",
+                    "next_seed": 9,
+                    "answer_ext": ".out",
+                    "candidates": [{"signature": "x"}],
+                    "errors": [{"seed": 1, "error": "e"}],
+                    "active_pids": [555],
+                },
+                f,
+            )
+
+        result = await tool.execute(problem_dir=tmpdir, kill_all_generators=True)
+        assert result.success
+        with open(state_path, encoding="utf-8") as f:
+            state = json.load(f)
+        if os.name == "nt":
+            assert state.get("active_pids") == []
+        else:
+            assert state.get("active_pids") == [555]
+        assert state.get("phase") == "partial"
+        assert state.get("next_seed") == 9
+        assert state.get("answer_ext") == ".out"
+
+
 @pytest.mark.asyncio
 async def test_problem_generate_tests_run_with_retry_keeps_pid_on_cancel(monkeypatch):
     """取消时 _run_with_retry 应保留 active_pids 供后续 cleanup 使用。"""
@@ -862,6 +908,30 @@ async def test_problem_pack_polygon_dynamic_test_count():
             assert "<test-count>20</test-count>" not in content
 
 
+@pytest.mark.asyncio
+async def test_problem_pack_polygon_sanitizes_answer_ext_from_manifest():
+    """manifest 中非法 answer_ext 不应污染 problem.xml。"""
+    create_tool = ProblemCreateTool()
+    pack_tool = ProblemPackPolygonTool()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        problem_dir = os.path.join(tmpdir, "pack_ext_sanitize")
+        await create_tool.execute(problem_dir=problem_dir, problem_name="Pack & Test")
+        tests_dir = os.path.join(problem_dir, "tests")
+        os.makedirs(tests_dir, exist_ok=True)
+        with open(os.path.join(tests_dir, "01.in"), "w", encoding="utf-8") as f:
+            f.write("1\n")
+        with open(os.path.join(tests_dir, ".autocode_tests_manifest.json"), "w", encoding="utf-8") as f:
+            json.dump({"answer_ext": ".bad<ext>"}, f)
+
+        result = await pack_tool.execute(problem_dir=problem_dir)
+        assert result.success
+        xml_path = os.path.join(problem_dir, "problem.xml")
+        with open(xml_path, encoding="utf-8") as f:
+            content = f.read()
+        assert "<answer-path-pattern>tests/%02d.ans</answer-path-pattern>" in content
+
+
 @pytest.mark.asyncio
 async def test_problem_generate_tests_dedup():
     """测试去重功能。"""