Fix python/web_search/configure_tevarn regressions and land chat inspector composer.

Windows SelectorEventLoop left the python tool dead; LLM integer strings failed schema; topic=status fell through to overview. Also keep composer menus and the inspector out of overflow clipping.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: wu1w

backend/agent/grant_store.py

@@ -197,6 +197,10 @@ def _prune_expired_locked() -> int:
     "manage_mcp": "manage_mcp",
     "manage_skill": "manage_skill",
     "generate_ppt": "file_rw",
+    "configure_tevarn": "manage_skill",
+    "update_config": "manage_skill",
+    "get_system_status": "current_time",
+    "list_available_models": "current_time",
 }
 
 
@@ -233,6 +237,10 @@ def sync_catalog_from_kernel(kernel: Any | None = None) -> bool:
         TOOL_TO_CREW_CAP.setdefault("generate_ppt", "file_rw")
         TOOL_TO_CREW_CAP.setdefault("current_time", "current_time")
         TOOL_TO_CREW_CAP.setdefault("result_load", "file_read")
+        TOOL_TO_CREW_CAP.setdefault("configure_tevarn", "manage_skill")
+        TOOL_TO_CREW_CAP.setdefault("update_config", "manage_skill")
+        TOOL_TO_CREW_CAP.setdefault("get_system_status", "current_time")
+        TOOL_TO_CREW_CAP.setdefault("list_available_models", "current_time")
         logger.info("grant_store catalog synced from rust (%s entries)", len(TOOL_TO_CREW_CAP))
         return True
     except Exception as e:

backend/agent/loop_cluster.py

@@ -14,6 +14,64 @@
 _tools_bootstrap_lock: asyncio.Lock | None = None
 
 
+def _try_coerce_int(val: Any) -> int | None:
+    if isinstance(val, bool) or val is None:
+        return None
+    if isinstance(val, int):
+        return int(val)
+    if isinstance(val, float):
+        return int(val) if val.is_integer() else None
+    if isinstance(val, str):
+        s = val.strip()
+        if not s:
+            return None
+        try:
+            if s.lstrip("+-").isdigit():
+                return int(s)
+            f = float(s)
+            if f.is_integer():
+                return int(f)
+        except (TypeError, ValueError, OverflowError):
+            return None
+    return None
+
+
+def _try_coerce_number(val: Any) -> int | float | None:
+    if isinstance(val, bool) or val is None:
+        return None
+    if isinstance(val, int):
+        return int(val)
+    if isinstance(val, float):
+        return val
+    if isinstance(val, str):
+        s = val.strip()
+        if not s:
+            return None
+        try:
+            n = float(s)
+        except (TypeError, ValueError, OverflowError):
+            return None
+        if n.is_integer() and "." not in s and "e" not in s.lower() and "E" not in s:
+            try:
+                return int(s)
+            except (TypeError, ValueError, OverflowError):
+                return n
+        return n
+    return None
+
+
+def _try_coerce_bool(val: Any) -> bool | None:
+    if isinstance(val, bool):
+        return val
+    if isinstance(val, str):
+        s = val.strip().lower()
+        if s in {"true", "yes", "on", "y"}:
+            return True
+        if s in {"false", "no", "off", "n"}:
+            return False
+    return None
+
+
 def _tools_bootstrap_lock_get() -> asyncio.Lock:
     global _tools_bootstrap_lock
     if _tools_bootstrap_lock is None:
@@ -320,6 +378,8 @@ def _validate_tool_args(self, schema: dict | None, arguments: dict) -> dict:
 
         if not schema:
             return cleaned
+        # LLM JSON 常把整数写成 "3"；先按 schema 类型软转换，再 clamp / validate
+        cleaned = self._coerce_tool_args(schema, cleaned)
         # 软夹紧：数值 min/max 越界时 clamp，减少「max_results=3 < min 5」类无意义失败
         cleaned = self._clamp_tool_args(schema, cleaned)
         try:
@@ -332,6 +392,44 @@ def _validate_tool_args(self, schema: dict | None, arguments: dict) -> dict:
             raise ValueError(f"Invalid tool arguments: {e.message}") from e
         return cleaned
 
+    @staticmethod
+    def _schema_prop_types(spec: dict) -> set[str]:
+        t = spec.get("type")
+        if isinstance(t, str) and t:
+            return {t}
+        if isinstance(t, (list, tuple)):
+            return {str(x) for x in t if x}
+        return set()
+
+    def _coerce_tool_args(self, schema: dict, cleaned: dict) -> dict:
+        """把 LLM 常见的字符串标量收成 schema 声明的 integer/number/boolean。"""
+        props = schema.get("properties") if isinstance(schema, dict) else None
+        if not isinstance(props, dict) or not cleaned:
+            return cleaned
+        out = dict(cleaned)
+        for key, spec in props.items():
+            if key not in out or not isinstance(spec, dict):
+                continue
+            types = self._schema_prop_types(spec)
+            if not types:
+                continue
+            val = out[key]
+            if "integer" in types:
+                coerced = _try_coerce_int(val)
+                if coerced is not None:
+                    out[key] = coerced
+                    continue
+            if "number" in types:
+                coerced = _try_coerce_number(val)
+                if coerced is not None:
+                    out[key] = coerced
+                    continue
+            if "boolean" in types:
+                coerced = _try_coerce_bool(val)
+                if coerced is not None:
+                    out[key] = coerced
+        return out
+
     def _clamp_tool_args(self, schema: dict, cleaned: dict) -> dict:
         """按 JSON Schema properties 的 minimum/maximum/minLength 做软夹紧（不改类型）。"""
         props = schema.get("properties") if isinstance(schema, dict) else None

backend/core/safe_subprocess.py

@@ -239,22 +239,36 @@ async def kill_process_tree(proc: asyncio.subprocess.Process | None) -> None:
     try:
         if sys.platform == "win32" and pid:
             # /T = tree; /F = force. Avoids orphaned cmd/python grandchildren.
-            killer = await asyncio.create_subprocess_exec(
-                "taskkill",
-                "/PID",
-                str(pid),
-                "/T",
-                "/F",
-                stdout=asyncio.subprocess.DEVNULL,
-                stderr=asyncio.subprocess.DEVNULL,
-            )
-            try:
-                await asyncio.wait_for(killer.wait(), timeout=5.0)
-            except Exception:
+            # SelectorEventLoop cannot create_subprocess_exec — same Popen fallback.
+            if _windows_selector_loop():
+                def _taskkill() -> None:
+                    import subprocess as _sp
+
+                    _sp.run(
+                        ["taskkill", "/PID", str(pid), "/T", "/F"],
+                        stdout=_sp.DEVNULL,
+                        stderr=_sp.DEVNULL,
+                        check=False,
+                    )
+
+                await asyncio.to_thread(_taskkill)
+            else:
+                killer = await asyncio.create_subprocess_exec(
+                    "taskkill",
+                    "/PID",
+                    str(pid),
+                    "/T",
+                    "/F",
+                    stdout=asyncio.subprocess.DEVNULL,
+                    stderr=asyncio.subprocess.DEVNULL,
+                )
                 try:
-                    killer.kill()
+                    await asyncio.wait_for(killer.wait(), timeout=5.0)
                 except Exception:
-                    pass
+                    try:
+                        killer.kill()
+                    except Exception:
+                        pass
         else:
             # start_new_session=True below → process group id == pid
             if pid and hasattr(os, "killpg"):
@@ -389,6 +403,32 @@ def _popen_thread_process(
     return _ThreadSubprocess(popen)
 
 
+def _popen_thread_argv(
+    argv: list[str],
+    *,
+    cwd: str | None,
+    env: dict[str, str] | None,
+) -> _ThreadSubprocess:
+    import subprocess as _sp
+
+    if not argv:
+        raise ValueError("empty argv")
+    creationflags = 0
+    if sys.platform == "win32":
+        creationflags = int(getattr(_sp, "CREATE_NEW_PROCESS_GROUP", 0) or 0)
+    popen = _sp.Popen(  # type: ignore[call-overload, arg-type]
+        argv,
+        shell=False,
+        cwd=cwd or None,
+        env=env,
+        stdin=_sp.DEVNULL,
+        stdout=_sp.PIPE,
+        stderr=_sp.PIPE,
+        creationflags=creationflags,
+    )
+    return _ThreadSubprocess(popen)
+
+
 async def create_process(
     command: str,
     *,
@@ -486,6 +526,48 @@ async def create_process(
         )
 
 
+async def create_process_exec(
+    *argv: str,
+    cwd: str | None = None,
+    env: dict[str, str] | None = None,
+) -> Any:
+    """Spawn argv without a shell (python.exe + script, etc.).
+
+    Windows SelectorEventLoop: threaded Popen — asyncio subprocess is
+    NotImplemented there (bare exception → empty ``[Error]`` for python tool).
+    """
+    argv_l = [str(a) for a in argv if str(a)]
+    if not argv_l:
+        raise ValueError("empty argv")
+    run_env: dict[str, str] | None = None
+    if env is not None:
+        run_env = {
+            str(k): str(v) for k, v in env.items() if k is not None and v is not None
+        }
+    if _windows_selector_loop():
+        return await asyncio.to_thread(
+            _popen_thread_argv, argv_l, cwd=cwd, env=run_env
+        )
+    spawn = _spawn_kwargs()
+    try:
+        return await asyncio.create_subprocess_exec(
+            *argv_l,
+            cwd=cwd or None,
+            env=run_env,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            **spawn,
+        )
+    except NotImplementedError:
+        logger.warning(
+            "asyncio exec NotImplemented; falling back to threaded Popen argv0=%s",
+            argv_l[0][:80],
+        )
+        return await asyncio.to_thread(
+            _popen_thread_argv, argv_l, cwd=cwd, env=run_env
+        )
+
+
 async def run_capture(
     command: str,
     *,

backend/services/tools/executors.py

@@ -2053,22 +2053,21 @@ def _cmd_quote(s: str) -> str:
 
         proc = None  # audit-fix: spawn 本身失败时 Timeout 分支不得引用未绑定变量
         try:
-            from backend.core.safe_subprocess import kill_process_tree
+            from backend.computer.text_decode import decode_process_bytes
+            from backend.core.safe_subprocess import create_process_exec
 
-            # stdin DEVNULL + process group so outer cancel can tree-kill
-            _spawn: dict = {
-                "stdout": asyncio.subprocess.PIPE,
-                "stderr": asyncio.subprocess.PIPE,
-                "stdin": asyncio.subprocess.DEVNULL,
-            }
-            if sys.platform != "win32":
-                _spawn["start_new_session"] = True
-            proc = await asyncio.create_subprocess_exec(py, script_path, **_spawn)
+            # Windows SelectorEventLoop: asyncio.create_subprocess_exec raises
+            # bare NotImplementedError → empty ``[Error] `` and a dead python tool.
+            try:
+                timeout_s = float(timeout or 30)
+            except (TypeError, ValueError):
+                timeout_s = 30.0
+            proc = await create_process_exec(py, script_path)
             stdout, stderr = await asyncio.wait_for(
-                proc.communicate(), timeout=timeout
+                proc.communicate(), timeout=timeout_s
             )
-            out = stdout.decode("utf-8", errors="replace").strip()
-            err = stderr.decode("utf-8", errors="replace").strip()
+            out = decode_process_bytes(stdout or b"").strip()
+            err = decode_process_bytes(stderr or b"").strip()
             if err:
                 return f"[Exit {proc.returncode}]\nstdout:\n{out}\n\nstderr:\n{err}"
             return out or "[No output]"
@@ -2095,7 +2094,8 @@ def _cmd_quote(s: str) -> str:
                     pass
             raise
         except Exception as e:
-            return f"[Error] {e}"
+            msg = str(e).strip() or type(e).__name__
+            return f"[Error] {type(e).__name__}: {msg}"
     finally:
         if script_path:
             try:

backend/skills/builtins/configure_tevarn_skill.py

@@ -21,6 +21,15 @@
 
 _LOW_RISK = {c["key"] for c in SETTINGS_CATALOG if c["risk"] == "low"}
 _HIGH_RISK = {c["key"] for c in SETTINGS_CATALOG if c["risk"] == "high"}
+_ACTION_NAMES = frozenset({
+    "guide",
+    "status",
+    "list_settings",
+    "set_setting",
+    "checklist",
+    "search",
+    "topics",
+})
 
 
 class ConfigureTevarnSkill(BaseSkill):
@@ -94,6 +103,11 @@ async def execute(
         **kwargs: Any,
     ) -> str:
         action = (action or "guide").strip().lower()
+        # 模型常把 action 写进 topic（topic=status），resolve_topic 会落到 overview。
+        topic_key = (topic or "").strip().lower()
+        if action in ("", "guide") and topic_key in _ACTION_NAMES and topic_key != "guide":
+            action = topic_key
+            topic = None
 
         if action == "topics":
             lines = ["可用手册主题："]

backend/tests/security/test_shell_injection.py

@@ -141,3 +141,31 @@ async def test_windows_env_backtick_injection_blocked(command: str) -> None:
     with pytest.raises(ValueError) as ei:
         await ss.create_process(command)
     assert "injection risk" in str(ei.value)
+
+
+@pytest.mark.asyncio
+async def test_create_process_exec_falls_back_on_not_implemented(monkeypatch) -> None:
+    async def _boom(*_a, **_k):
+        raise NotImplementedError()
+
+    monkeypatch.setattr(ss.asyncio, "create_subprocess_exec", _boom)
+    monkeypatch.setattr(ss, "_windows_selector_loop", lambda: False)
+    proc = await ss.create_process_exec(sys.executable, "-c", "print(42)")
+    out, _err = await proc.communicate()
+    assert b"42" in out
+
+
+@pytest.mark.asyncio
+async def test_create_process_exec_selector_skips_asyncio_subprocess(monkeypatch) -> None:
+    called = []
+
+    async def _boom(*_a, **_k):
+        called.append(1)
+        raise AssertionError("asyncio subprocess must not run on SelectorEventLoop path")
+
+    monkeypatch.setattr(ss, "_windows_selector_loop", lambda: True)
+    monkeypatch.setattr(ss.asyncio, "create_subprocess_exec", _boom)
+    proc = await ss.create_process_exec(sys.executable, "-c", "print(42)")
+    out, _err = await proc.communicate()
+    assert b"42" in out
+    assert called == []

backend/tests/test_agent_grant_short_circuit.py

@@ -27,6 +27,8 @@ def test_tool_matches_command_cap():
     assert tool_matches_crew_caps("command", ["command", "file_rw"])
     assert tool_matches_crew_caps("python", ["command"])
     assert not tool_matches_crew_caps("command", ["file_rw"])
+    assert tool_matches_crew_caps("configure_tevarn", ["manage_skill"])
+    assert tool_matches_crew_caps("get_system_status", ["current_time"])
 
 
 def test_session_whole_tool_covers_any_command_head():

backend/tests/test_cap_grant.py

@@ -58,6 +58,10 @@ def test_tool_to_cap_map():
     assert crew_cap_for_tool("command") == "command"
     assert crew_cap_for_tool("file_write") == "file_rw"
     assert crew_cap_for_tool("web_search") == "web_search"
+    assert crew_cap_for_tool("configure_tevarn") == "manage_skill"
+    assert crew_cap_for_tool("update_config") == "manage_skill"
+    assert crew_cap_for_tool("get_system_status") == "current_time"
+    assert crew_cap_for_tool("list_available_models") == "current_time"
 
 
 def test_auto_grant_eligibility():