fix: log idle-reminder task-count failures; test grep fallback via public API

Address two CodeRabbit review findings on PR #13:

- ui/shell: replace contextlib.suppress(Exception) around the idle-reminder
  active-task count with a try/except that logs at debug (active_running still
  falls back to 0), so background-task introspection failures are no longer
  invisible.
- tests/tools/test_grep: exercise the Python fallback's wall-clock bound through
  the public Grep() API with a forced ripgrep-unavailable path instead of
  calling _python_grep directly, and drop the now-unused import.

Author: elkaix

src/pythinker_code/ui/shell/__init__.py

@@ -795,12 +795,18 @@ def _can_auto_trigger_pending() -> bool:
                         resume_prompt.set()
                         active_running = 0
                         if isinstance(self.soul, PythinkerSoul):
-                            with contextlib.suppress(Exception):
+                            try:
                                 active_running = len(
                                     list_task_views(
                                         self.soul.runtime.background_tasks, active_only=True
                                     )
                                 )
+                            except Exception:
+                                logger.debug(
+                                    "Failed to compute active background task count for "
+                                    "idle reminder",
+                                    exc_info=True,
+                                )
                         ok = await self.run_soul_command(_background_idle_reminder(active_running))
                         console.print()
                         if not ok:

tests/tools/test_grep.py

@@ -15,7 +15,6 @@
     Params,
     _build_rg_args,
     _find_existing_rg,
-    _python_grep,
     _rg_binary_name,
     _strip_path_prefix,
 )
@@ -1041,24 +1040,33 @@ async def test_grep_allows_env_example(grep_tool: Grep):
         assert ".env.example" in result.output
 
 
-def test_python_fallback_bounds_wall_clock(monkeypatch, tmp_path):
+async def test_python_fallback_bounds_wall_clock(monkeypatch, tmp_path):
     """The Python fallback caps total wall-clock like the ripgrep path, and
     surfaces a partial-results notice when it does."""
+
+    async def fail_rg_path() -> str:
+        raise RuntimeError("Failed to download ripgrep binary")
+
+    monkeypatch.setattr("pythinker_code.tools.file.grep_local._ensure_rg_path", fail_rg_path)
+
     (tmp_path / "a.txt").write_text("needle\n")
     (tmp_path / "b.txt").write_text("needle\n")
 
-    # First monotonic() reading establishes the deadline; every later reading is
-    # far in the future, so the deadline is already blown on the first file.
-    readings = iter([0.0])
+    # A strictly increasing clock: the first reading inside the fallback sets the
+    # deadline, and the next reading (during the file walk) is far enough ahead to
+    # blow it immediately. The +1e9 step keeps that true regardless of any other
+    # monotonic() calls made elsewhere on the public Grep() path.
+    ticks = [0.0]
 
     def _fake_monotonic() -> float:
-        return next(readings, 1e9)
+        value = ticks[0]
+        ticks[0] += 1e9
+        return value
 
     monkeypatch.setattr(grep_module.time, "monotonic", _fake_monotonic)
 
-    result = _python_grep(
-        Params(pattern="needle", path=str(tmp_path), output_mode="files_with_matches"),
-        "forced fallback",
+    result = await Grep()(
+        Params(pattern="needle", path=str(tmp_path), output_mode="files_with_matches")
     )
 
     assert f"Search exceeded {grep_module.RG_TIMEOUT}s" in result.message