fix: Windows兼容性修复 + P1-24弱模型优化 + 3.2.9b禁止降级方案 + AirRvr三层审查放行标准

- lock.py: 跨平台进程锁（Unix fcntl / Windows msvcrt / O_CREAT|O_EXCL降级）
- eng_mode.py/eng_orchestrator.py: hasattr(os, "getloadavg") Windows防护
- arc_mode.py: 路径分隔符 replace("\\", "/") Windows兼容
- deploy_runtime.py: 修复语法错误（清理 import tempfile 残留）
- P1-24(3.2.18): AMBIGUOUS_VERBS歧义词检测 + SAFE_VERBS安全动词 + validate_task_description()
- TaskNode.keep_constraints 保留约束字段 + JSON序列化
- _build_graph_from_todo 返回歧义警告 + Arc自检集成
- 3.2.9b: FORBIDDEN_DEGRADATION_PATTERNS + check_forbidden_degradation()
- AirRvr三层审查放行标准: ReviewVerdict + evaluate_review_pass() + is_forbidden_pass_reason()
- commands/arc.md: 弱模型安全重写（操作类型拆分+保留约束+自检）
- commands/do.md/eng.md/rvr.md: 禁止降级方案 + 三层审查标准
- 测试: 7个新测试 + 74全量通过

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

lib/air_runtime/lock.py

@@ -1,43 +1,123 @@
 """
-文件级并发控制 — 解决 V1 P0-4 零并发控制问题。
-基于 fcntl.flock 的进程级文件锁，超时自动释放。
+文件级并发控制 — 跨平台进程级文件锁。
+Unix: fcntl.flock (POSIX)
+Windows: msvcrt.locking (Win32)
+均不支持时: 原子文件创建 (O_CREAT | O_EXCL)
 """
 
 from __future__ import annotations
 
-import fcntl
 import os
 import time
+import sys
 from pathlib import Path
 
 
+def _lock_file_unix(fd: int) -> None:
+    import fcntl
+    fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+
+def _unlock_file_unix(fd: int) -> None:
+    import fcntl
+    fcntl.flock(fd, fcntl.LOCK_UN)
+
+
+def _lock_file_windows(fd: int) -> None:
+    import msvcrt
+    msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+
+
+def _unlock_file_windows(fd: int) -> None:
+    import msvcrt
+    msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
+
+
+if sys.platform == "win32":
+    try:
+        import msvcrt
+        _lock_fn = _lock_file_windows
+        _unlock_fn = _unlock_file_windows
+    except ImportError:
+        _lock_fn = None
+        _unlock_fn = None
+else:
+    try:
+        import fcntl  # noqa: F401
+        _lock_fn = _lock_file_unix
+        _unlock_fn = _unlock_file_unix
+    except ImportError:
+        _lock_fn = None
+        _unlock_fn = None
+
+
 class FileLock:
-    """基于 fcntl.flock(LOCK_EX | LOCK_NB) 的进程级文件锁"""
+    """跨平台进程级文件锁。
+
+    Unix: fcntl.flock(LOCK_EX | LOCK_NB)
+    Windows: msvcrt.locking(LK_NBLCK)
+    降级方案: 原子文件创建 (O_CREAT | O_EXCL)
+    """
 
     def __init__(self, path: Path, timeout: float = 10.0):
-        self._path = path.with_suffix(path.suffix + ".lock") if not path.suffix.endswith(".lock") else path
+        lock_suffix = ".lock" if not path.suffix.endswith(".lock") else ""
+        self._path = path.with_suffix(path.suffix + lock_suffix) if lock_suffix else path
         self._timeout = timeout
         self._fd: int | None = None
+        self._fallback = _lock_fn is None
 
-    def __enter__(self) -> FileLock:
-        self._fd = os.open(self._path, os.O_CREAT | os.O_RDWR)
+    def __enter__(self) -> "FileLock":
+        if self._fallback:
+            self._acquire_fallback()
+        else:
+            self._acquire_native()
+        return self
+
+    def __exit__(self, *exc) -> None:
+        if self._fallback:
+            self._release_fallback()
+        elif self._fd is not None:
+            _unlock_fn(self._fd)
+            os.close(self._fd)
+            self._fd = None
+
+    def _acquire_native(self) -> None:
+        self._fd = os.open(str(self._path), os.O_CREAT | os.O_RDWR)
         deadline = time.monotonic() + self._timeout
         while True:
             try:
-                fcntl.flock(self._fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                return self
-            except OSError:
+                _lock_fn(self._fd)
+                return
+            except (OSError, IOError):
                 if time.monotonic() >= deadline:
                     os.close(self._fd)
                     self._fd = None
                     raise TimeoutError(f"lock timeout after {self._timeout}s: {self._path}")
                 time.sleep(0.1)
 
-    def __exit__(self, *exc) -> None:
+    def _acquire_fallback(self) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        deadline = time.monotonic() + self._timeout
+        while True:
+            try:
+                self._fd = os.open(
+                    str(self._path),
+                    os.O_CREAT | os.O_EXCL | os.O_WRONLY,
+                )
+                return
+            except FileExistsError:
+                if time.monotonic() >= deadline:
+                    raise TimeoutError(f"lock timeout after {self._timeout}s: {self._path}")
+                time.sleep(0.1)
+
+    def _release_fallback(self) -> None:
         if self._fd is not None:
-            fcntl.flock(self._fd, fcntl.LOCK_UN)
             os.close(self._fd)
             self._fd = None
+        try:
+            self._path.unlink(missing_ok=True)
+        except OSError:
+            pass
 
     @property
     def path(self) -> Path: