@michelj/context-guard 0.4.0 → 0.4.2

package/skills/context-guard/scripts/context_guard.py

@@ -4,18 +4,15 @@
 from __future__ import annotations
 
 import argparse
-import contextlib
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import html
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-import io
 import json
 import os
 import re
 import shutil
 import subprocess
 import sys
-import threading
 import webbrowser
 from datetime import datetime
 from pathlib import Path
@@ -3630,6 +3627,10 @@ def test_registry_path(ctx: Path) -> Path:
     return ctx / "test-hub" / "registry.json"
 
 
+def feature_chains_path(ctx: Path) -> Path:
+    return ctx / "test-hub" / "feature-chains.json"
+
+
 def default_test_registry() -> dict[str, object]:
     return {
         "version": 1,
@@ -3673,6 +3674,206 @@ def next_test_id(ctx: Path, title: str) -> str:
     return f"TC-{today}-{(max(numbers) + 1 if numbers else 1):03d}-{normalize_test_slug(title)[:36]}"
 
 
+def default_feature_chain_registry() -> dict[str, object]:
+    return {
+        "version": 1,
+        "description": "Feature-oriented test chains. One chain should cover a real workflow and multiple linked bad-case recurrence checks.",
+        "chains": [],
+    }
+
+
+def load_feature_chains(ctx: Path) -> dict[str, object]:
+    path = feature_chains_path(ctx)
+    if not path.exists():
+        return default_feature_chain_registry()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        print(f"[context-guard] invalid feature-chain JSON: {path}", file=sys.stderr)
+        return default_feature_chain_registry()
+    if not isinstance(data, dict):
+        return default_feature_chain_registry()
+    chains = data.get("chains")
+    if not isinstance(chains, list):
+        data["chains"] = []
+    data.setdefault("version", 1)
+    data.setdefault("description", default_feature_chain_registry()["description"])
+    return data
+
+
+def write_feature_chains(ctx: Path, registry: dict[str, object]) -> Path:
+    path = feature_chains_path(ctx)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(registry, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return path
+
+
+def next_feature_chain_id(ctx: Path) -> str:
+    today = datetime.now().strftime("%Y%m%d")
+    registry = load_feature_chains(ctx)
+    existing = " ".join(
+        str(chain.get("id", "")) for chain in registry.get("chains", []) if isinstance(chain, dict)
+    )
+    numbers = [int(match.group(1)) for match in re.finditer(rf"FC-{today}-(\d+)", existing)]
+    return f"FC-{today}-{(max(numbers) + 1 if numbers else 1):03d}"
+
+
+def feature_chain_find(
+    ctx: Path, chain_id: str
+) -> tuple[dict[str, object], list[dict[str, object]], dict[str, object]]:
+    registry = load_feature_chains(ctx)
+    chains = registry.setdefault("chains", [])
+    if not isinstance(chains, list):
+        chains = []
+        registry["chains"] = chains
+    matches = [item for item in chains if isinstance(item, dict) and str(item.get("id", "")) == chain_id]
+    if not matches:
+        raise ValueError(f"feature chain not found: {chain_id}")
+    return matches[0], chains, registry
+
+
+def feature_chain_add(
+    root: Path,
+    title: str,
+    entry: str,
+    exit_check: str,
+    command_text: str = "",
+    run_policy: str = RUN_ALWAYS_POLICY,
+    status: str = "proposed",
+    timeout_seconds: int = 300,
+    artifact_policy: str = "cleanup-on-pass",
+    resource: str = "local",
+) -> Path:
+    init_context(root)
+    ctx = context_dir(root)
+    if not title.strip():
+        raise ValueError("feature-chain-add requires --title")
+    if not entry.strip():
+        raise ValueError("feature-chain-add requires --entry")
+    if not exit_check.strip():
+        raise ValueError("feature-chain-add requires --exit-check")
+    registry = load_feature_chains(ctx)
+    chains = registry.setdefault("chains", [])
+    if not isinstance(chains, list):
+        chains = []
+        registry["chains"] = chains
+    chain_id = next_feature_chain_id(ctx)
+    now = datetime.now().isoformat(timespec="seconds")
+    chains.append(
+        {
+            "id": chain_id,
+            "title": title.strip(),
+            "status": status.strip() or "proposed",
+            "run_policy": run_policy.strip() or RUN_ALWAYS_POLICY,
+            "entry": entry.strip(),
+            "exit_check": exit_check.strip(),
+            "type": "command" if command_text.strip() else "manual",
+            "command": command_text.strip(),
+            "cwd": ".",
+            "resource": resource.strip() or "local",
+            "timeout_seconds": int(timeout_seconds),
+            "artifact_policy": artifact_policy.strip() or "cleanup-on-pass",
+            "blocker_keywords": BLOCKER_PATTERNS,
+            "nodes": [],
+            "created_at": now,
+            "updated_at": now,
+            "source": "feature-chain",
+        }
+    )
+    path = write_feature_chains(ctx, registry)
+    print(f"[context-guard] feature chain: {chain_id}")
+    print(f"[context-guard] registry: {path}")
+    return path
+
+
+def feature_chain_attach_bc(
+    root: Path,
+    chain_id: str,
+    node_title: str,
+    bad_case: str,
+    check: str = "",
+) -> Path:
+    init_context(root)
+    ctx = context_dir(root)
+    if not chain_id.strip():
+        raise ValueError("feature-chain-attach-bc requires --chain-id")
+    if not node_title.strip():
+        raise ValueError("feature-chain-attach-bc requires --node-title")
+    if not bad_case.strip():
+        raise ValueError("feature-chain-attach-bc requires --bad-case")
+    chain, _chains, registry = feature_chain_find(ctx, chain_id.strip())
+    nodes = chain.setdefault("nodes", [])
+    if not isinstance(nodes, list):
+        nodes = []
+        chain["nodes"] = nodes
+    node_slug = normalize_test_slug(node_title)
+    node: dict[str, object] | None = None
+    for item in nodes:
+        if not isinstance(item, dict):
+            continue
+        if str(item.get("title", "")).strip() == node_title.strip() or str(item.get("id", "")) == node_slug:
+            node = item
+            break
+    if node is None:
+        node = {
+            "id": node_slug,
+            "title": node_title.strip(),
+            "checks": [],
+            "bad_cases": [],
+            "created_at": datetime.now().isoformat(timespec="seconds"),
+        }
+        nodes.append(node)
+    bad_cases = node.setdefault("bad_cases", [])
+    if not isinstance(bad_cases, list):
+        bad_cases = []
+        node["bad_cases"] = bad_cases
+    if bad_case.strip() not in [str(item) for item in bad_cases]:
+        bad_cases.append(bad_case.strip())
+    checks = node.setdefault("checks", [])
+    if not isinstance(checks, list):
+        checks = []
+        node["checks"] = checks
+    if check.strip() and check.strip() not in [str(item) for item in checks]:
+        checks.append(check.strip())
+    now = datetime.now().isoformat(timespec="seconds")
+    node["updated_at"] = now
+    chain["updated_at"] = now
+    path = write_feature_chains(ctx, registry)
+    print(f"[context-guard] feature chain updated: {chain_id.strip()}")
+    print(f"[context-guard] node: {node_title.strip()}")
+    print(f"[context-guard] bad case: {bad_case.strip()}")
+    return path
+
+
+def feature_chain_list(root: Path) -> int:
+    init_context(root)
+    ctx = context_dir(root)
+    registry = load_feature_chains(ctx)
+    chains = [item for item in registry.get("chains", []) if isinstance(item, dict)]
+    if not chains:
+        print("[context-guard] feature chains: none.")
+        print(f"[context-guard] registry: {feature_chains_path(ctx)}")
+        return 0
+    print("[context-guard] feature chains:")
+    for chain in chains:
+        chain_id = str(chain.get("id", "unknown"))
+        title = str(chain.get("title", "untitled"))
+        status = str(chain.get("status", "unknown"))
+        run_policy = str(chain.get("run_policy", "unset"))
+        nodes = [item for item in chain.get("nodes", []) if isinstance(item, dict)]
+        covered = sorted(
+            {
+                str(bc)
+                for node in nodes
+                for bc in (node.get("bad_cases", []) if isinstance(node.get("bad_cases", []), list) else [])
+            }
+        )
+        suffix = f" | covers {', '.join(covered)}" if covered else ""
+        print(f"- {chain_id} | {status} | {run_policy} | {title} | {len(nodes)} node(s){suffix}")
+    print(f"[context-guard] registry: {feature_chains_path(ctx)}")
+    return 0
+
+
 def test_hub_add(
     root: Path,
     title: str,
@@ -3740,7 +3941,8 @@ def test_hub_list(root: Path) -> int:
     ctx = context_dir(root)
     registry_tests = test_hub_registry_tests(ctx)
     task_case_tests = discover_task_case_tests(ctx)
-    if not registry_tests and not task_case_tests:
+    feature_chain_tests = approved_feature_chain_tests(ctx)
+    if not registry_tests and not task_case_tests and not feature_chain_tests:
         print("[context-guard] test hub: no registered tests.")
         print(f"[context-guard] registry: {test_registry_path(ctx)}")
         return 0
@@ -3761,6 +3963,17 @@ def test_hub_list(root: Path) -> int:
             title = str(test.get("title", "untitled"))
             source = str(test.get("source", "task-cases"))
             print(f"- {test_id} | {test.get('status')} | {test.get('run_policy')} | {title} | {source}")
+    if feature_chain_tests:
+        print("[context-guard] approved feature-chain tests:")
+        for test in feature_chain_tests:
+            test_id = str(test.get("id", "unknown"))
+            title = str(test.get("title", "untitled"))
+            source = str(test.get("source", "feature-chain"))
+            covered = test.get("covered_bad_cases", [])
+            covered_suffix = ""
+            if isinstance(covered, list) and covered:
+                covered_suffix = f" | covers {', '.join(str(item) for item in covered)}"
+            print(f"- {test_id} | {test.get('status')} | {test.get('run_policy')} | {title} | {source}{covered_suffix}")
     print(f"[context-guard] registry: {test_registry_path(ctx)}")
     return 0
 
@@ -3781,8 +3994,9 @@ def test_hub_state(root: Path) -> dict[str, object]:
     ctx = context_dir(root)
     registry_tests = test_hub_registry_tests(ctx)
     task_case_tests = discover_task_case_tests(ctx)
+    feature_chain_tests = approved_feature_chain_tests(ctx)
     tests: list[dict[str, object]] = []
-    for source, items in (("registry", registry_tests), ("task-case", task_case_tests)):
+    for source, items in (("registry", registry_tests), ("task-case", task_case_tests), ("feature-chain", feature_chain_tests)):
         for item in items:
             status = str(item.get("status", "unknown")).strip() or "unknown"
             run_policy = str(item.get("run_policy", item.get("run policy", "unset"))).strip() or "unset"
@@ -3954,20 +4168,6 @@ def render_test_hub_html(root: Path) -> str:
     p {{ margin: 0; }}
     .subtle, .muted {{ color: var(--muted); }}
     .actions {{ display: flex; gap: 12px; align-items: center; flex-wrap: wrap; }}
-    button {{
-      appearance: none;
-      border: 1px solid var(--accent);
-      border-radius: 999px;
-      padding: 6px 13px;
-      color: white;
-      background: var(--accent);
-      font: inherit;
-      font-size: 12px;
-      font-weight: 760;
-      cursor: pointer;
-      box-shadow: 0 0 0 4px var(--accent-soft);
-    }}
-    button:disabled {{ cursor: not-allowed; opacity: .45; }}
     .hub-board {{
       background: var(--panel);
       border: 1px solid var(--line);
@@ -3989,7 +4189,7 @@ def render_test_hub_html(root: Path) -> str:
       gap: 10px;
       margin-bottom: 14px;
     }}
-    .metric, .test-card, .empty, .log {{
+    .metric, .test-card, .empty {{
       background: var(--card);
       border: 1px solid var(--line);
       border-radius: var(--radius);
@@ -4051,8 +4251,6 @@ def render_test_hub_html(root: Path) -> str:
       font-size: 12px;
     }}
     .empty {{ padding: 22px; text-align: center; }}
-    .log {{ display: none; margin-top: 14px; padding: 12px; white-space: pre-wrap; font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 12px; }}
-    .log.visible {{ display: block; }}
     @media (max-width: 760px) {{
       header, .shell {{ padding-left: 16px; padding-right: 16px; }}
       .header-row, .card-head, .board-head {{ flex-direction: column; align-items: flex-start; }}
@@ -4065,11 +4263,10 @@ def render_test_hub_html(root: Path) -> str:
     <div class="header-row">
       <div>
         <h1>测试中台</h1>
-        <p class="subtle">查看用户已确认的测试；localhost 控制台支持一键运行。</p>
+        <p class="subtle">查看用户已确认的测试；开发结束时由 Context Guard 自动运行。</p>
       </div>
       <div class="actions">
-        <button id="run-all" type="button">运行所有测试</button>
-        <p id="mode" class="subtle"></p>
+        <p class="subtle">只读状态页</p>
       </div>
     </div>
   </header>
@@ -4090,39 +4287,10 @@ def render_test_hub_html(root: Path) -> str:
     <section class="grid" aria-label="测试列表">
       {''.join(rows)}
     </section>
-    <pre id="log" class="log"></pre>
     </section>
   </main>
   <script>
     window.__TEST_HUB_STATE__ = {state_json};
-    const runButton = document.getElementById('run-all');
-    const mode = document.getElementById('mode');
-    const log = document.getElementById('log');
-    const canRun = location.protocol === 'http:' || location.protocol === 'https:';
-    if (!canRun) {{
-      runButton.disabled = true;
-      mode.textContent = '一键运行需要 serve-test-hub 启动 localhost 控制台';
-    }} else {{
-      mode.textContent = 'localhost 控制台已启用';
-    }}
-    runButton.addEventListener('click', async () => {{
-      if (!canRun) return;
-      runButton.disabled = true;
-      runButton.textContent = '运行中...';
-      log.classList.add('visible');
-      log.textContent = '正在运行已确认测试...';
-      try {{
-        const response = await fetch('/api/run', {{ method: 'POST' }});
-        const data = await response.json();
-        log.textContent = data.output || JSON.stringify(data, null, 2);
-        setTimeout(() => location.reload(), 900);
-      }} catch (error) {{
-        log.textContent = String(error);
-      }} finally {{
-        runButton.disabled = false;
-        runButton.textContent = '运行所有测试';
-      }}
-    }});
   </script>
 </body>
 </html>
@@ -4143,7 +4311,6 @@ def show_test_hub(root: Path, open_browser: bool = False) -> Path:
 
 def serve_test_hub(root: Path, host: str, port: int, jobs: int, open_browser: bool = False) -> int:
     init_context(root)
-    run_lock = threading.Lock()
 
     class TestHubHandler(BaseHTTPRequestHandler):
         def log_message(self, format: str, *args: object) -> None:
@@ -4173,29 +4340,7 @@ def serve_test_hub(root: Path, host: str, port: int, jobs: int, open_browser: bo
             self.send_json(404, {"error": "not found"})
 
         def do_POST(self) -> None:
-            path = urlparse(self.path).path
-            if path != "/api/run":
-                self.send_json(404, {"error": "not found"})
-                return
-            if not run_lock.acquire(blocking=False):
-                self.send_json(409, {"status": "busy", "output": "测试正在运行，请稍后。"})
-                return
-            stdout = io.StringIO()
-            stderr = io.StringIO()
-            try:
-                with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
-                    code = test_hub_dev_complete(root, jobs=jobs)
-                output = stdout.getvalue() + stderr.getvalue()
-                self.send_json(
-                    200 if code == 0 else 500,
-                    {
-                        "status": "passed" if code == 0 else "failed",
-                        "code": code,
-                        "output": output,
-                    },
-                )
-            finally:
-                run_lock.release()
+            self.send_json(405, {"error": "test hub page is read-only; tests run from the Stop hook or `dev-complete`."})
 
     server = ThreadingHTTPServer((host, port), TestHubHandler)
     actual_host, actual_port = server.server_address[:2]
@@ -4289,6 +4434,43 @@ def discover_task_case_tests(ctx: Path) -> list[dict[str, object]]:
     return tests
 
 
+def approved_feature_chain_tests(ctx: Path) -> list[dict[str, object]]:
+    registry = load_feature_chains(ctx)
+    tests: list[dict[str, object]] = []
+    for item in registry.get("chains", []):
+        if not isinstance(item, dict):
+            continue
+        status = str(item.get("status", "")).strip().lower()
+        run_policy = str(item.get("run_policy", item.get("run policy", ""))).strip()
+        if status not in APPROVED_TEST_STATUSES or run_policy != RUN_ALWAYS_POLICY:
+            continue
+        command = str(item.get("command", "")).strip()
+        nodes = [node for node in item.get("nodes", []) if isinstance(node, dict)]
+        covered_bad_cases = sorted(
+            {
+                str(bc)
+                for node in nodes
+                for bc in (node.get("bad_cases", []) if isinstance(node.get("bad_cases", []), list) else [])
+                if str(bc).strip()
+            }
+        )
+        normalized = dict(item)
+        normalized["id"] = str(item.get("id") or item.get("title") or "feature-chain")
+        normalized["title"] = str(item.get("title") or normalized["id"])
+        normalized["run_policy"] = run_policy
+        normalized["type"] = "command" if command else "manual"
+        normalized["command"] = command
+        normalized.setdefault("cwd", ".")
+        normalized.setdefault("timeout_seconds", 300)
+        normalized.setdefault("artifact_policy", "cleanup-on-pass")
+        normalized.setdefault("resource", "local")
+        normalized.setdefault("blocker_keywords", BLOCKER_PATTERNS)
+        normalized["source"] = "feature-chain"
+        normalized["covered_bad_cases"] = covered_bad_cases
+        tests.append(normalized)
+    return tests
+
+
 def approved_registry_tests(ctx: Path) -> list[dict[str, object]]:
     registry = load_test_registry(ctx)
     tests: list[dict[str, object]] = []
@@ -4311,7 +4493,7 @@ def approved_registry_tests(ctx: Path) -> list[dict[str, object]]:
 
 def approved_dev_completion_tests(ctx: Path) -> list[dict[str, object]]:
     by_id: dict[str, dict[str, object]] = {}
-    for test in approved_registry_tests(ctx) + discover_task_case_tests(ctx):
+    for test in approved_registry_tests(ctx) + discover_task_case_tests(ctx) + approved_feature_chain_tests(ctx):
         test_id = str(test.get("id") or test.get("title") or "unnamed")
         by_id[test_id] = test
     return list(by_id.values())
@@ -4502,7 +4684,7 @@ def create_branch_task(root: Path, title: str, branch: str, parent_node: str = "
 
 def main() -> int:
     parser = argparse.ArgumentParser(description="Context Guard utilities")
-    parser.add_argument("command", choices=["init", "set-language", "export-roadmap", "show-roadmap", "create-branch-task", "checkpoint-roadmap-node", "validate-bad-cases", "validate-roadmap-maintenance", "test-hub-add", "test-hub-list", "test-hub-enable", "test-hub-disable", "test-hub-set-policy", "test-hub-remove", "show-test-hub", "serve-test-hub", "dev-complete"])
+    parser.add_argument("command", choices=["init", "set-language", "export-roadmap", "show-roadmap", "create-branch-task", "checkpoint-roadmap-node", "validate-bad-cases", "validate-roadmap-maintenance", "test-hub-add", "test-hub-list", "test-hub-enable", "test-hub-disable", "test-hub-set-policy", "test-hub-remove", "feature-chain-add", "feature-chain-attach-bc", "feature-chain-list", "show-test-hub", "serve-test-hub", "dev-complete"])
     parser.add_argument("--format", choices=["html", "md"], default="html")
     parser.add_argument("--language", default=None, help="Folder-scoped language for future context records.")
     parser.add_argument("--title", default=None, help="Title for a branch task or roadmap checkpoint.")
@@ -4514,6 +4696,12 @@ def main() -> int:
     parser.add_argument("--timeout-seconds", type=int, default=300, help="Timeout for a registered test command.")
     parser.add_argument("--artifact-policy", default="cleanup-on-pass", help="Artifact policy for a registered test command.")
     parser.add_argument("--resource", default="local", help="Resource/node label for a registered test command.")
+    parser.add_argument("--entry", default="", help="Human-readable entry point for a feature-chain test.")
+    parser.add_argument("--exit-check", default="", help="Human-readable success condition for a feature-chain test.")
+    parser.add_argument("--chain-id", default="", help="Feature chain ID for feature-chain management commands.")
+    parser.add_argument("--node-title", default="", help="Feature-chain node title for attaching bad-case coverage.")
+    parser.add_argument("--bad-case", default="", help="Bad-case ID or title covered by a feature-chain node.")
+    parser.add_argument("--check", default="", help="Checkpoint text for a feature-chain node.")
     parser.add_argument("--jobs", type=int, default=1, help="Parallel test workers for dev-complete.")
     parser.add_argument("--host", default="127.0.0.1", help="Host for serve-test-hub.")
     parser.add_argument("--port", type=int, default=8772, help="Port for serve-test-hub.")
@@ -4604,6 +4792,43 @@ def main() -> int:
             resource=args.resource,
         )
         return 0
+    if args.command == "feature-chain-add":
+        if not args.title:
+            parser.error("feature-chain-add requires --title")
+        if not args.entry:
+            parser.error("feature-chain-add requires --entry")
+        if not args.exit_check:
+            parser.error("feature-chain-add requires --exit-check")
+        feature_chain_add(
+            root,
+            title=args.title,
+            entry=args.entry,
+            exit_check=args.exit_check,
+            command_text=args.command_text,
+            run_policy=args.run_policy,
+            status=args.test_status,
+            timeout_seconds=args.timeout_seconds,
+            artifact_policy=args.artifact_policy,
+            resource=args.resource,
+        )
+        return 0
+    if args.command == "feature-chain-attach-bc":
+        if not args.chain_id:
+            parser.error("feature-chain-attach-bc requires --chain-id")
+        if not args.node_title:
+            parser.error("feature-chain-attach-bc requires --node-title")
+        if not args.bad_case:
+            parser.error("feature-chain-attach-bc requires --bad-case")
+        feature_chain_attach_bc(
+            root,
+            chain_id=args.chain_id,
+            node_title=args.node_title,
+            bad_case=args.bad_case,
+            check=args.check,
+        )
+        return 0
+    if args.command == "feature-chain-list":
+        return feature_chain_list(root)
     if args.command == "test-hub-list":
         return test_hub_list(root)
     if args.command == "test-hub-enable":

package/skills/context-guard/scripts/context_guard_hook.py

@@ -14,7 +14,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-from context_guard import context_dir, init_context
+from context_guard import approved_dev_completion_tests, context_dir, init_context
 
 
 SKILL_ROOT = Path(__file__).resolve().parents[1]
@@ -147,6 +147,41 @@ def hook_response(**payload: object) -> int:
     return 0
 
 
+def run_test_hub_completion(root: Path) -> tuple[int, str]:
+    ctx = context_dir(root)
+    tests = approved_dev_completion_tests(ctx)
+    if not tests:
+        return 0, "[context-guard] test hub: no approved every-dev-completion tests."
+
+    hook_log(f"[context-guard] test hub: running {len(tests)} approved every-dev-completion test(s).")
+    completed = subprocess.run(
+        [
+            sys.executable,
+            str(SKILL_ROOT / "scripts" / "context_guard.py"),
+            "dev-complete",
+            "--root",
+            str(root),
+        ],
+        text=True,
+        capture_output=True,
+        timeout=900,
+    )
+    output = "\n".join(part for part in [completed.stdout.strip(), completed.stderr.strip()] if part)
+    return completed.returncode, output
+
+
+def completion_test_summary(output: str, code: int) -> str:
+    if "no approved every-dev-completion tests" in output:
+        return "no approved every-dev-completion tests"
+    for line in output.splitlines():
+        if "[context-guard] test hub:" in line and " passed," in line and " failed," in line and " blocked" in line:
+            summary = line.split("test hub:", 1)[1].strip().rstrip(".")
+            if code == 0:
+                return f"all approved tests passed ({summary})"
+            return f"approved tests are not all passing ({summary})"
+    return "test hub status unknown; inspect `.codex/context/test-hub/last-run.json`"
+
+
 def prompt_text(raw: str) -> str:
     if not raw.strip():
         return ""
@@ -437,7 +472,7 @@ def main() -> int:
         hook_log("[context-guard] COMPLETION RELIABILITY GATE: use existing user screenshots/logs/reproductions as red evidence when available; implement once the cause is clear, then run the smallest real post-fix check. Default budget is one primary check plus at most two highly relevant bad-case guards.")
         hook_log("[context-guard] BAD-CASE GUARD GATE: newly checked resolved or recurred BC entries need Guard type, Red condition, Green condition, Expected failure reason, and a red-capable Guard / verification; run `context_guard.py validate-bad-cases` only after register/schema/renderer edits, or `--strict` when intentionally migrating/checking all resolved cases.")
         hook_log("[context-guard] GUARD SELECTION GATE: do not run every historical guard and do not manufacture new red tests when credible evidence already exists. Select guards by changed files, feature area, route branch, tags, and original user-visible symptom; skip unrelated resolved cases.")
-        hook_log("[context-guard] TEST HUB GATE: before finalizing development work, prefer `context_guard.py dev-complete --root <project>` so the hub runs every human-approved `every-dev-completion` test, cleans success artifacts, and preserves failed/blocked evidence. Do not treat ordinary bad-case guards or roadmap Test chain notes as registered tests.")
+        hook_log("[context-guard] TEST HUB GATE: Stop hook runs `context_guard.py dev-complete --root <project>` so the hub executes every human-approved `every-dev-completion` test, cleans success artifacts, and preserves failed/blocked evidence. Do not treat ordinary bad-case guards or roadmap Test chain notes as registered tests.")
         hook_log("[context-guard] TASK-CASE GATE: when a workflow has multiple phases, prefer one relevant task case from `.codex/context/task-cases/` with phase/checkpoint logs over many isolated bug-level tests; report the failed phase/checkpoint if it breaks.")
         hook_log("[context-guard] TEST BLOCKER GATE: if approved tests are blocked by credentials, external service outage, permission denial, hardware/resource limits, network, destructive-risk confirmation, or user-only judgment, stop and ask/warn the user with the exact blocker and evidence path.")
         hook_log("[context-guard] TASK-CASE DESIGN GATE: before writing a new durable task-case script for a complex workflow, ask the user to confirm a short business-facing proposal: from what state to what state, main task, and major risk; keep technical details inside the task-case file, or keep it `proposed` if unavailable.")
@@ -452,6 +487,28 @@ def main() -> int:
         hook_log(f"[context-guard] project root: {root}")
         hook_log(f"[context-guard] context folder: {context_dir}")
         hook_log(f"[context-guard] bad-case register: {bad_cases_path}")
+        try:
+            test_code, test_output = run_test_hub_completion(root)
+            for line in test_output.splitlines():
+                hook_log(line)
+            hook_log(
+                "[context-guard] final answer must include Test Hub summary: "
+                + completion_test_summary(test_output, test_code)
+            )
+            if test_code != 0:
+                reason = (
+                    "Context Guard Test Hub found failed or blocked approved tests. "
+                    "Read `.codex/context/test-hub/last-run.json` and preserved run evidence, "
+                    "then fix or report the blocker before finalizing."
+                )
+                hook_log(f"[context-guard] TEST HUB BLOCKER: {reason}")
+                return hook_response(decision="block", reason=reason)
+        except subprocess.TimeoutExpired:
+            reason = "Context Guard Test Hub timed out after 900s; report this blocker and evidence before finalizing."
+            hook_log(f"[context-guard] TEST HUB BLOCKER: {reason}")
+            return hook_response(decision="block", reason=reason)
+        except Exception as exc:
+            hook_log(f"[context-guard] test hub hook warning: {exc}")
         open_cases = unresolved_bad_cases(bad_cases_path)
         hook_log("[context-guard] final answer must include BC summary: archived/updated BC this turn, and current unresolved BC.")
         hook_log(f"[context-guard] current unresolved BC: {format_unresolved_bad_cases(open_cases)}")

package/skills/context-guard/tests/BC-20260702-096.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/scripts/context_guard.py}"
+ROOT="$(mktemp -d "${TMPDIR:-/tmp}/context-guard-feature-chain-XXXXXX")"
+trap 'rm -rf "$ROOT"' EXIT
+
+python3 "$SCRIPT" init --root "$ROOT" >/dev/null
+
+ADD_OUTPUT="$(python3 "$SCRIPT" feature-chain-add \
+  --root "$ROOT" \
+  --title "GPU 监控按钮" \
+  --entry "点击 GPU 监控按钮" \
+  --exit-check "打开包含有效 grafana_url 的监控页" \
+  --command-text "printf 'feature-chain-ok\n'" \
+  --test-status approved)"
+
+CHAIN_ID="$(printf '%s\n' "$ADD_OUTPUT" | awk '/feature chain:/ {print $NF}')"
+test -n "$CHAIN_ID"
+
+python3 "$SCRIPT" feature-chain-attach-bc \
+  --root "$ROOT" \
+  --chain-id "$CHAIN_ID" \
+  --node-title "后端返回监控 URL" \
+  --bad-case "BC-20260702-000" \
+  --check "grafana_url 不为空，前端不会卡住" >/dev/null
+
+python3 "$SCRIPT" feature-chain-list --root "$ROOT" | grep -q "BC-20260702-000"
+
+python3 - "$ROOT/.codex/context/test-hub/feature-chains.json" "$CHAIN_ID" <<'PY'
+from pathlib import Path
+import json
+import sys
+
+data = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+chain = next(item for item in data["chains"] if item["id"] == sys.argv[2])
+assert chain["entry"] == "点击 GPU 监控按钮"
+assert chain["exit_check"] == "打开包含有效 grafana_url 的监控页"
+assert chain["nodes"][0]["bad_cases"] == ["BC-20260702-000"]
+assert "grafana_url 不为空" in chain["nodes"][0]["checks"][0]
+PY
+
+RUN_OUTPUT="$(python3 "$SCRIPT" dev-complete --root "$ROOT")"
+printf '%s\n' "$RUN_OUTPUT" | grep -q "1 passed, 0 failed, 0 blocked"
+printf '%s\n' "$RUN_OUTPUT" | grep -q "success artifacts cleaned"