@michelj/context-guard 0.4.1 → 0.4.3

package/{skills/context-guard/scripts → scripts}/context_guard_hook.py

@@ -1,20 +1,22 @@
 #!/usr/bin/env python3
 """Lightweight lifecycle reminders for the Context Guard plugin.
 
-The hook initializes folder-scoped context on session start and nudges Codex to
-use the context-guard skill at the two moments where omission is most costly:
-prompt intake and turn stop.
+The hook initializes folder-scoped context on session/subagent start and nudges
+Codex to use the context-guard skill at the moments where omission is most
+costly: prompt intake, turn stop, and subagent stop.
 """
 
 from __future__ import annotations
 
 import json
 import os
+import re
 import subprocess
 import sys
+from datetime import datetime
 from pathlib import Path
 
-from context_guard import approved_dev_completion_tests, context_dir, init_context
+from context_guard import approved_dev_completion_tests, context_dir, init_context, resolve_registered_subagent_root
 
 
 SKILL_ROOT = Path(__file__).resolve().parents[1]
@@ -109,7 +111,47 @@ def parse_hook_payload(raw: str) -> object:
         return {}
 
 
-def event_root(raw: str, cwd: Path) -> tuple[Path, str]:
+def hook_agent_id(payload: object) -> str:
+    keys = {"agent_id", "agentId", "subagent_id", "subagentId"}
+    found: list[str] = []
+
+    def walk(value: object) -> None:
+        if isinstance(value, dict):
+            for key, child in value.items():
+                if key in keys and isinstance(child, str) and child.strip():
+                    found.append(child.strip())
+                walk(child)
+        elif isinstance(value, list):
+            for child in value:
+                walk(child)
+
+    walk(payload)
+    return found[0] if found else ""
+
+
+def hook_text_field(payload: object, key: str) -> str:
+    if not isinstance(payload, dict):
+        return ""
+    value = payload.get(key)
+    return value.strip() if isinstance(value, str) else ""
+
+
+def registered_subagent_control_root(payload: object, cwd: Path, agent_id: str) -> Path | None:
+    if not agent_id:
+        return None
+    candidates = [*possible_workspace_paths(payload), cwd]
+    seen: set[Path] = set()
+    for path in candidates:
+        control_root = git_root(path).resolve()
+        if control_root in seen:
+            continue
+        seen.add(control_root)
+        if resolve_registered_subagent_root(control_root, agent_id):
+            return control_root
+    return None
+
+
+def event_root(raw: str, cwd: Path, event: str = "") -> tuple[Path, str]:
     payload = parse_hook_payload(raw)
     candidates: list[tuple[Path, str]] = []
     for path in possible_workspace_paths(payload):
@@ -122,6 +164,13 @@ def event_root(raw: str, cwd: Path) -> tuple[Path, str]:
                 candidates.append((path, f"${key}"))
     candidates.append((cwd, "process cwd"))
 
+    agent_id = hook_agent_id(payload) if event in {"subagent-start", "subagent-stop"} else ""
+    control_root = registered_subagent_control_root(payload, cwd, agent_id)
+    if control_root:
+        assigned = resolve_registered_subagent_root(control_root, agent_id)
+        if assigned and not is_context_guard_skill_path(assigned):
+            return assigned, f"registered subagent assignment ({agent_id})"
+
     for path, source in candidates:
         root = git_root(path)
         if not is_context_guard_skill_path(root):
@@ -147,6 +196,107 @@ def hook_response(**payload: object) -> int:
     return 0
 
 
+SECRET_PATTERNS = [
+    re.compile(r"(?i)\b(password|passwd|pwd|token|api[_-]?key|secret|access[_-]?key|private[_-]?key)\b\s*[:=]\s*([^\s,;]+)"),
+    re.compile(r"\bnpm_[A-Za-z0-9]{20,}\b"),
+    re.compile(r"\bgh[pousr]_[A-Za-z0-9_]{20,}\b"),
+    re.compile(r"\bsk-[A-Za-z0-9_-]{20,}\b"),
+]
+EPHEMERAL_SECRET_PATTERN = re.compile(r"(?i)\b(otp|one[- ]?time password|验证码|一次性验证码)\b\s*[:=]?\s*([0-9]{4,8})?")
+
+
+def has_secret(text: str) -> bool:
+    return any(pattern.search(text) for pattern in SECRET_PATTERNS)
+
+
+def has_ephemeral_secret(text: str) -> bool:
+    return bool(EPHEMERAL_SECRET_PATTERN.search(text))
+
+
+def redact_user_message(text: str) -> str:
+    redacted = text
+    for pattern in SECRET_PATTERNS:
+        if pattern.groups >= 2:
+            redacted = pattern.sub(lambda m: f"{m.group(1)}=<redacted>", redacted)
+        else:
+            redacted = pattern.sub("<redacted-secret>", redacted)
+    redacted = EPHEMERAL_SECRET_PATTERN.sub(lambda m: f"{m.group(1)}=<redacted-ephemeral>", redacted)
+    return redacted
+
+
+def write_private_secret(ctx: Path, raw_text: str, redacted_text: str) -> str:
+    private_dir = ctx / "private"
+    private_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        private_dir.chmod(0o700)
+    except OSError:
+        pass
+    path = private_dir / "secrets.local.json"
+    try:
+        data = json.loads(path.read_text(encoding="utf-8")) if path.exists() else []
+    except json.JSONDecodeError:
+        data = []
+    if not isinstance(data, list):
+        data = []
+    secret_id = "USER-SECRET-" + datetime.now().strftime("%Y%m%d-%H%M%S")
+    data.append(
+        {
+            "id": secret_id,
+            "created": datetime.now().isoformat(timespec="seconds"),
+            "redacted": redacted_text,
+            "raw": raw_text,
+            "note": "Local-only Context Guard secret memory. Do not copy into roadmap, HTML, git, logs, or final answers.",
+        }
+    )
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    try:
+        path.chmod(0o600)
+    except OSError:
+        pass
+    return secret_id
+
+
+def append_user_message(ctx: Path, text: str) -> tuple[str, str]:
+    clean = text.strip()
+    if not clean:
+        return "skipped", "empty prompt"
+    init_context(ctx.parent.parent)
+    path = ctx / "user-messages.md"
+    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    is_large = len(clean) > 1600 or clean.count("\n") > 30
+    ephemeral = has_ephemeral_secret(clean)
+    secret = has_secret(clean)
+    redacted = redact_user_message(clean)
+    secret_ref = ""
+    if secret and not ephemeral and len(clean) <= 4000:
+        secret_ref = write_private_secret(ctx, clean, redacted)
+    if is_large:
+        first_line = redacted.splitlines()[0][:240]
+        stored = f"Large user message or attachment; first line: {first_line}"
+        mode = "summary"
+    else:
+        stored = redacted
+        mode = "verbatim" if not secret and not ephemeral else "redacted"
+    if ephemeral:
+        secret_ref = "ephemeral-not-stored"
+        mode = "ephemeral"
+    body = path.read_text(encoding="utf-8") if path.exists() else "# User Message Memory\n\n## Recent User Signals\n\n"
+    if stored and stored in body[-4000:]:
+        return "skipped", "duplicate recent message"
+    entry = [
+        f"\n### {now}",
+        f"- Mode: {mode}",
+        f"- User message: {stored}",
+    ]
+    if secret_ref:
+        entry.append(f"- Secret pointer: {secret_ref}")
+    entry.append("- Use: Preserve this wording when deciding task direction, constraints, credentials, preferences, bad-case intake, or roadmap `User request` fields.")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write("\n".join(entry) + "\n")
+    return "recorded", mode
+
+
 def run_test_hub_completion(root: Path) -> tuple[int, str]:
     ctx = context_dir(root)
     tests = approved_dev_completion_tests(ctx)
@@ -182,6 +332,43 @@ def completion_test_summary(output: str, code: int) -> str:
     return "test hub status unknown; inspect `.codex/context/test-hub/last-run.json`"
 
 
+def completion_test_failure_details(root: Path, limit: int = 3) -> str:
+    path = context_dir(root) / "test-hub" / "last-run.json"
+    if not path.exists():
+        return ""
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return ""
+    results = data.get("results", [])
+    if not isinstance(results, list):
+        return ""
+    not_passing = [
+        item
+        for item in results
+        if isinstance(item, dict) and str(item.get("status", "")).strip().lower() in {"failed", "blocked"}
+    ]
+    if not not_passing:
+        return ""
+
+    pieces: list[str] = []
+    for item in not_passing[:limit]:
+        title = str(item.get("title") or item.get("id") or "unnamed test").strip()
+        status = str(item.get("status") or "failed").strip()
+        reason = str(item.get("reason") or "no reason recorded").strip()
+        log = str(item.get("log") or "").strip()
+        if log:
+            try:
+                log = str(Path(log).resolve().relative_to(root.resolve()))
+            except Exception:
+                pass
+        suffix = f"; log: {log}" if log else ""
+        pieces.append(f"{status}: {title} — {reason}{suffix}")
+    if len(not_passing) > limit:
+        pieces.append(f"+{len(not_passing) - limit} more; inspect `.codex/context/test-hub/last-run.json`")
+    return "; ".join(pieces)
+
+
 def prompt_text(raw: str) -> str:
     if not raw.strip():
         return ""
@@ -322,6 +509,53 @@ def looks_like_test_creation(text: str) -> bool:
     return any(marker in lowered for marker in creation_markers) and any(marker in lowered for marker in test_markers)
 
 
+def looks_like_test_opportunity(text: str) -> bool:
+    lowered = text.lower()
+    opportunity_markers = [
+        "fix",
+        "bug",
+        "regression",
+        "workflow",
+        "flow",
+        "e2e",
+        "integration",
+        "ui",
+        "html",
+        "browser",
+        "frontend",
+        "backend",
+        "api",
+        "service",
+        "deploy",
+        "release",
+        "refactor",
+        "goal mode",
+        "long-running",
+        "修复",
+        "bug",
+        "问题",
+        "复发",
+        "回归",
+        "流程",
+        "链路",
+        "前端",
+        "后端",
+        "接口",
+        "服务",
+        "部署",
+        "发布",
+        "重构",
+        "页面",
+        "浏览器",
+        "远程",
+        "服务器",
+        "goal 模式",
+        "目标模式",
+        "长期",
+    ]
+    return any(marker in lowered for marker in opportunity_markers)
+
+
 def looks_like_explicit_branch(text: str) -> bool:
     lowered = text.lower()
     markers = [
@@ -414,7 +648,7 @@ def format_unresolved_bad_cases(cases: list[dict[str, str]], limit: int = 5) ->
 def main() -> int:
     event = sys.argv[1] if len(sys.argv) > 1 else "unknown"
     raw = read_stdin()
-    root, root_source = event_root(raw, Path.cwd())
+    root, root_source = event_root(raw, Path.cwd(), event)
     context_dir = root / ".codex" / "context"
     index_path = context_dir / "index.md"
     roadmap_path = context_dir / "roadmap.md"
@@ -430,25 +664,40 @@ def main() -> int:
         hook_log(f"[context-guard] apparent root source: {root_source}; apparent root: {root}")
         return hook_response()
 
-    if event == "session-start":
+    if event in {"session-start", "subagent-start"}:
         created = init_context(root)
+        label = "subagent context" if event == "subagent-start" else "folder context"
         if created:
-            hook_log(f"[context-guard] initialized folder context: {context_dir}")
+            hook_log(f"[context-guard] initialized {label}: {context_dir}")
         else:
-            hook_log(f"[context-guard] folder context ready: {context_dir}")
+            hook_log(f"[context-guard] {label} ready: {context_dir}")
         hook_log(f"[context-guard] project root: {root} ({root_source})")
         hook_log("[context-guard] context location rule: save project context only under `<opened local Codex project root>/.codex/context/`.")
         hook_log("[context-guard] use .codex/context/index.md for quick scan and .codex/context/roadmap.md for route nodes.")
         return hook_response()
 
     if event == "user-prompt-submit":
+        record_status, record_mode = append_user_message(context_dir, text)
         hints: list[str] = []
+        if record_status == "recorded":
+            if record_mode == "redacted":
+                hints.append("user message memory: saved latest prompt with secrets redacted; raw secret, if durable, is local-only under `.codex/context/private/`")
+            elif record_mode == "ephemeral":
+                hints.append("user message memory: saved latest prompt with one-time code redacted; raw ephemeral code was not persisted")
+            elif record_mode == "summary":
+                hints.append("user message memory: saved a concise summary of the latest large prompt instead of copying the full blob")
+            else:
+                hints.append("user message memory: saved latest short user prompt in `.codex/context/user-messages.md`")
+        else:
+            hints.append(f"user message memory: skipped ({record_mode})")
         if looks_like_goal_mode(text):
             hints.append("goal mode: align active goal with current context and record roadmap/bad-case checkpoints during long-running work")
         if looks_like_remote_work(text):
             hints.append("remote/SSH work: keep `.codex/context` in the local Codex workspace; record remote host/path as metadata and do not initialize roadmap context on the server unless explicitly requested")
         if looks_like_test_creation(text):
             hints.append("explicit test creation: start the user-visible response with `测试创建识别：...`, summarize the test target from state A to state B, and only create durable tests after the user's design is clear or confirmed")
+        elif looks_like_test_opportunity(text):
+            hints.append("test opportunity: if this task changes a reusable workflow, fixes a recurring/user-visible bug, or is likely to regress, gently ask whether the user wants to create a test task; keep it optional and do not create durable tests without approval")
         if looks_like_explicit_branch(text):
             hints.append("explicit branch task: create/select a branch task by running `context_guard.py create-branch-task --title <task title> --branch <branch name> --parent-node <parent NODE id>` before implementation; verify the roadmap node has Branch: and Parent:")
         elif looks_like_route_drift(text):
@@ -467,15 +716,17 @@ def main() -> int:
         hook_log(f"[context-guard] route map: {roadmap_path}")
         return hook_response()
 
-    if event == "stop":
-        hook_log("[context-guard] run turn-end checkpoint before finalizing or updating a goal: update index, route map nodes, parked/resume tasks, and relevant bad-case/test-chain links.")
+    if event in {"stop", "subagent-stop"}:
+        lifecycle_label = "SubagentStop" if event == "subagent-stop" else "Stop"
+        hook_log(f"[context-guard] {lifecycle_label} checkpoint: update index, route map nodes, parked/resume tasks, and relevant bad-case/test-chain links before finalizing.")
         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: 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] TEST HUB GATE: Stop/SubagentStop hooks run `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.")
+        hook_log("[context-guard] TEST OPPORTUNITY GATE: if this turn changed a reusable workflow, fixed a recurring/user-visible bug, or created a phase that is likely to regress, include a brief optional nudge asking whether the user wants to create a test task. Do not create durable tests unless the user confirms.")
         hook_log("[context-guard] GOAL-MODE TEST GATE: in goal mode, use task cases as phase gates; log current phase progress and run the smallest approved path before claiming goal completion instead of silently creating broad new tests.")
         hook_log("[context-guard] ROADMAP CHECKPOINT GATE: assess whether this turn deserves a roadmap node. Create one only for meaningful progress, a route decision, a fix, a branch/fork, a user-visible milestone, or stale hidden checkpoints; otherwise say no roadmap node was needed and why.")
         hook_log("[context-guard] If a node is needed, run `context_guard.py checkpoint-roadmap-node --title <short title> --branch <Main or route> --level <major|checkpoint> --outcome <one-line progress> --next-step <next>` and include linked BC/test-chain notes when relevant.")
@@ -487,6 +738,59 @@ 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}")
+        if event == "subagent-stop":
+            payload = parse_hook_payload(raw)
+            agent_id = hook_agent_id(payload)
+            last_message = hook_text_field(payload, "last_assistant_message")
+            control_root = registered_subagent_control_root(payload, Path.cwd(), agent_id)
+            command_root = control_root or root
+            command = [
+                sys.executable,
+                str(SKILL_ROOT / "scripts" / "context_guard.py"),
+                "subagent-complete",
+                "--root",
+                str(command_root),
+                "--agent-id",
+                agent_id,
+                "--summary",
+                last_message,
+            ]
+            try:
+                completed = subprocess.run(
+                    command,
+                    cwd=str(root),
+                    text=True,
+                    capture_output=True,
+                    timeout=900,
+                )
+            except subprocess.TimeoutExpired:
+                reason = "Context Guard subagent completion timed out after 900s."
+                hook_log(f"[context-guard] TEST HUB BLOCKER: {reason}")
+                return hook_response(decision="block", reason=reason)
+            except Exception as exc:
+                reason = f"Context Guard could not run subagent completion: {exc}"
+                hook_log(f"[context-guard] COMPLETION BLOCKER: {reason}")
+                return hook_response(decision="block", reason=reason)
+            completion_output = "\n".join(
+                part for part in [completed.stdout.strip(), completed.stderr.strip()] if part
+            )
+            for line in completion_output.splitlines():
+                hook_log(line)
+            hook_log(
+                "[context-guard] final answer must include Test Hub summary: "
+                + completion_test_summary(completion_output, completed.returncode)
+            )
+            if completed.returncode != 0:
+                details = completion_test_failure_details(root)
+                reason = "Context Guard subagent completion found failed or blocked approved tests."
+                if details:
+                    reason += " Failing tests: " + details
+                hook_log(f"[context-guard] TEST HUB BLOCKER: {reason}")
+                return hook_response(decision="block", reason=reason)
+            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)}")
+            return hook_response()
         try:
             test_code, test_output = run_test_hub_completion(root)
             for line in test_output.splitlines():
@@ -496,11 +800,16 @@ def main() -> int:
                 + completion_test_summary(test_output, test_code)
             )
             if test_code != 0:
+                details = completion_test_failure_details(root)
+                if details:
+                    hook_log("[context-guard] failing approved test details: " + details)
                 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."
                 )
+                if details:
+                    reason += " Failing tests: " + details
                 hook_log(f"[context-guard] TEST HUB BLOCKER: {reason}")
                 return hook_response(decision="block", reason=reason)
         except subprocess.TimeoutExpired:
@@ -509,6 +818,29 @@ def main() -> int:
             return hook_response(decision="block", reason=reason)
         except Exception as exc:
             hook_log(f"[context-guard] test hub hook warning: {exc}")
+        try:
+            auto_propose = subprocess.run(
+                [
+                    sys.executable,
+                    str(SKILL_ROOT / "scripts" / "context_guard.py"),
+                    "feature-chain-auto-propose",
+                    "--root",
+                    str(root),
+                    "--from-hook",
+                ],
+                cwd=str(root),
+                text=True,
+                capture_output=True,
+                timeout=10,
+            )
+            output = (auto_propose.stdout + auto_propose.stderr).strip()
+            if output:
+                for line in output.splitlines():
+                    hook_log(line)
+            if auto_propose.returncode != 0:
+                hook_log(f"[context-guard] feature-chain auto-propose warning: exit {auto_propose.returncode}")
+        except Exception as exc:
+            hook_log(f"[context-guard] feature-chain auto-propose 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 → tests}/BC-20260701-090.sh

@@ -46,11 +46,11 @@ cat > "$CTX/bad-cases.md" <<'MD'
 - Phenomenon: 普通 bad case guard 被误当成用户测试。
 - Guard / verification: 这是普通复发检查，不是用户批准测试。
 
-### BC-20260701-002: 用户批准测试应显示
+### BC-20260701-002: 用户批准测试也不应显示在概览
 - Status: resolved
 - Roadmap nodes: NODE-20260701-002
 - Tags: #roadmap-ux
-- Phenomenon: 用户批准的测试需要显示在线路上。
+- Phenomenon: 用户批准的测试不应在路线图概览下方形成第二行卡片。
 - Guard / verification: 运行用户确认的测试。
 - Run policy: every-dev-completion
 MD
@@ -73,11 +73,12 @@ html = Path(sys.argv[1]).read_text()
 body = html.split("</style>", 1)[1]
 notes = re.findall(r'<a class="route-test-note"[^>]*>(.*?)</a>', body, re.S)
 joined = "\n".join(notes)
-if "用户批准测试应显示" not in joined:
-    raise SystemExit("approved test did not appear in the route test line")
 if "普通 bad case guard 不应显示为测试" in joined:
     raise SystemExit("ordinary linked bad-case guard appeared as a test route item")
-test_items = len(notes)
-if test_items != 1:
-    raise SystemExit(f"expected exactly one approved test route item, got {test_items}")
+if "用户批准测试也不应显示在概览" in joined:
+    raise SystemExit("approved test appeared as a compact overview route item")
+if notes:
+    raise SystemExit(f"overview should not render compact route test notes, got {len(notes)}")
+if 'class="route-test-line' in body:
+    raise SystemExit("overview should not render compact route test line containers")
 PY

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

@@ -11,9 +11,7 @@ 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)"
+  --exit-check "打开包含有效 grafana_url 的监控页")"
 
 CHAIN_ID="$(printf '%s\n' "$ADD_OUTPUT" | awk '/feature chain:/ {print $NF}')"
 test -n "$CHAIN_ID"
@@ -25,6 +23,11 @@ python3 "$SCRIPT" feature-chain-attach-bc \
   --bad-case "BC-20260702-000" \
   --check "grafana_url 不为空，前端不会卡住" >/dev/null
 
+python3 "$SCRIPT" feature-chain-approve \
+  --root "$ROOT" \
+  --chain-id "$CHAIN_ID" \
+  --command-text "printf 'CG_CHECKPOINT:后端返回监控 URL:PASS\n'" >/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'

package/tests/BC-20260706-098.sh

@@ -0,0 +1,66 @@
+#!/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-method-XXXXXX")"
+trap 'rm -rf "$ROOT"' EXIT
+
+python3 "$SCRIPT" init --root "$ROOT" >/dev/null
+
+ADD_OUTPUT="$(python3 "$SCRIPT" feature-chain-add \
+  --root "$ROOT" \
+  --title "Markdown 公式预览" \
+  --entry "用户输入包含单行和多行公式的 Markdown" \
+  --exit-check "预览区展示 MathJax 渲染结果且没有空白或报错")"
+
+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 "公式输入进入预览流程" \
+  --bad-case "BC-20260706-001" \
+  --check "输入包含 $ 和 $$ 公式时预览流程没有丢弃公式文本" >/dev/null
+
+python3 "$SCRIPT" feature-chain-attach-bc \
+  --root "$ROOT" \
+  --chain-id "$CHAIN_ID" \
+  --node-title "MathJax 渲染完成" \
+  --bad-case "BC-20260706-002" \
+  --check "渲染完成后页面不显示原始 LaTeX、空白或错误占位" >/dev/null
+
+python3 "$SCRIPT" feature-chain-attach-bc \
+  --root "$ROOT" \
+  --chain-id "$CHAIN_ID" \
+  --node-title "MathJax 渲染完成" \
+  --bad-case "BC-20260706-003" \
+  --check "重复开发后单行、多行、矩阵公式仍共用同一预览链路验证" >/dev/null
+
+COMMAND="tmp=.codex/context/test-hub/feature-chain-evidence.tmp; printf 'CG_CHECKPOINT:公式输入进入预览流程:PASS\nCG_CHECKPOINT:MathJax 渲染完成:PASS\n' > \"\$tmp\"; cat \"\$tmp\"; rm -f \"\$tmp\""
+python3 "$SCRIPT" feature-chain-approve \
+  --root "$ROOT" \
+  --chain-id "$CHAIN_ID" \
+  --command-text "$COMMAND" >/dev/null
+
+python3 "$SCRIPT" feature-chain-list --root "$ROOT" | grep -q "covers BC-20260706-001, BC-20260706-002, BC-20260706-003"
+
+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["title"] == "Markdown 公式预览"
+assert len(chain["nodes"]) == 2
+covered = sorted(bc for node in chain["nodes"] for bc in node["bad_cases"])
+assert covered == ["BC-20260706-001", "BC-20260706-002", "BC-20260706-003"]
+assert chain["run_policy"] == "every-dev-completion"
+assert chain["status"] == "approved"
+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"
+test ! -e "$ROOT/.codex/context/test-hub/feature-chain-evidence.tmp"

package/tests/BC-20260707-099.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/scripts/context_guard.py"
+ROOT="$(mktemp -d "${TMPDIR:-/tmp}/context-guard-feature-chain-validate-XXXXXX")"
+trap 'rm -rf "$ROOT"' EXIT
+OUT="$ROOT/validate.out"
+
+python3 "$SCRIPT" init --root "$ROOT" >/dev/null
+
+ADD_OUTPUT="$(python3 "$SCRIPT" feature-chain-add \
+  --root "$ROOT" \
+  --title "Markdown 公式预览" \
+  --entry "用户输入 Markdown 公式" \
+  --exit-check "预览区显示 MathJax 渲染结果" \
+  --command-text "printf 'ok\n'")"
+
+CHAIN_ID="$(printf '%s\n' "$ADD_OUTPUT" | sed -n 's/.*feature chain: //p')"
+
+python3 - "$ROOT/.codex/context/test-hub/feature-chains.json" "$CHAIN_ID" <<'PY'
+from pathlib import Path
+import json
+import sys
+path = Path(sys.argv[1])
+chain_id = sys.argv[2]
+data = json.loads(path.read_text(encoding="utf-8"))
+chain = next(item for item in data["chains"] if item["id"] == chain_id)
+chain["status"] = "approved"
+chain["type"] = "command"
+path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+PY
+
+if python3 "$SCRIPT" validate-feature-chains --root "$ROOT" >"$OUT" 2>&1; then
+  cat "$OUT"
+  exit 1
+fi
+grep -q "approved every-dev-completion chain must have at least one checkpoint node" "$OUT"
+
+python3 "$SCRIPT" feature-chain-attach-bc \
+  --root "$ROOT" \
+  --chain-id "$CHAIN_ID" \
+  --node-title "MathJax 渲染完成" \
+  --bad-case "BC-20260707-099" \
+  --check "预览区包含渲染后的公式且没有空白" >/dev/null
+
+python3 "$SCRIPT" validate-feature-chains --root "$ROOT" >"$OUT"
+grep -q "feature-chain validation passed: 1 chain(s), 0 warning(s)" "$OUT"