claude-dev-env 7.2.0 → 7.2.1

package/.agents/skills/everything-search/SKILL.md

@@ -15,7 +15,11 @@ Search files instantly on Windows using the Everything command-line interface (e
 
 Every search carries a scope: a project path or registry token, an `ext:` filter, a `dm:` date filter, a `size:` filter, or a name pattern. A bare whole-drive scan or a network-share sweep is out of bounds. Narrow the search to what you need.
 
-When `es.exe` fails or returns nothing, self-heal first: fall back to the `Glob` tool (name and path patterns) or `Grep` (file contents), and report the outage so the reader knows the index was unavailable. When self-healing also fails, ask the user through `AskUserQuestion` with a short analysis and next-step options.
+When `es.exe` returns Error 8, the Everything IPC client window is missing. Retry the same search twice with a short pause. Do not report that Everything is not running, not loaded, or that the index is unavailable from that first miss. After those retries fail, report that the Everything IPC client did not answer and that the service state was not probed, then fall back to the `Glob` tool (name and path patterns) or `Grep` (file contents) with the same scope.
+
+When `es.exe` is missing, or a later search returns no hits, fall back to `Glob` or `Grep`. A failed search is not proof the index is down. When those fallbacks also fail, ask the user through `AskUserQuestion` with a short analysis and next-step options.
+
+Direct `es.exe` calls use the same Error 8 retry. The wrapper in `scripts/everything_search.py` already retries Error 8 twice.
 
 ## Registry tokens
 
@@ -139,7 +143,8 @@ Run separate searches for each extension type:
 
 ## Best Practices
 
-- Everything must be running (system tray) for es.exe to work
+- `es.exe` talks to the Everything tray client IPC window. The Everything service can be running while Error 8 still fires.
+- On Error 8, retry the same search twice before treating the search as failed.
 - Run one extension per search for cleaner results
 - Use `dm:` to filter recent files by the index timestamp
 - Combine with path to narrow scope
@@ -165,5 +170,5 @@ Everything indexes REAL paths only, not junctions or mapped drives.
 
 ## Files
 
-- `scripts/everything_search.py` runs one Everything search without a shell.
-- `scripts/test_everything_search.py` verifies registry expansion and command failures.
+- `scripts/everything_search.py` runs one Everything search without a shell, retries Error 8 twice, and reports that the IPC client did not answer and that the service state was not probed when those retries fail.
+- `scripts/test_everything_search.py` verifies registry expansion, command failures, Error 8 retry, and the IPC-client miss message.

package/.agents/skills/everything-search/scripts/everything_search.py

@@ -4,6 +4,7 @@ import json
 import shutil
 import subprocess
 import sys
+import time
 from collections.abc import Mapping, Sequence
 from pathlib import Path, PurePosixPath, PureWindowsPath
 from typing import TextIO
@@ -14,6 +15,10 @@ from everything_search_command_constants.config.constants import (
     EXECUTION_ERROR_EXIT_CODE,
     INFORMATIONAL_ARGUMENT,
     INVALID_INPUT_EXIT_CODE,
+    IPC_CLIENT_DID_NOT_ANSWER_MESSAGE,
+    IPC_WINDOW_NOT_FOUND_EXIT_CODE,
+    IPC_WINDOW_RETRY_COUNT,
+    IPC_WINDOW_RETRY_DELAY_SECONDS,
     PROJECT_PATHS_FILE_NAME,
     REGISTRY_META_KEY,
     SEARCH_SCOPE_REQUIRED_MESSAGE,
@@ -115,21 +120,32 @@ def _run_search(
     search_stdout: TextIO,
     search_stderr: TextIO,
 ) -> int:
-    try:
-        search_run = subprocess.run(
-            [executable_path, *all_search_arguments],
-            capture_output=True,
-            check=False,
-            encoding=UTF8_ENCODING,
-            shell=False,
-            text=True,
-        )
-    except OSError as error:
-        search_stderr.write(f"{error}\n")
-        return EXECUTION_ERROR_EXIT_CODE
-    search_stdout.write(search_run.stdout)
-    search_stderr.write(search_run.stderr)
-    return search_run.returncode
+    ipc_client_did_not_answer_message = IPC_CLIENT_DID_NOT_ANSWER_MESSAGE
+    ipc_window_not_found_exit_code = IPC_WINDOW_NOT_FOUND_EXIT_CODE
+    ipc_window_retry_count = IPC_WINDOW_RETRY_COUNT
+    ipc_window_retry_delay_seconds = IPC_WINDOW_RETRY_DELAY_SECONDS
+    last_search_run = None
+    for each_attempt_index in range(ipc_window_retry_count + 1):
+        try:
+            last_search_run = subprocess.run(
+                [executable_path, *all_search_arguments],
+                capture_output=True,
+                check=False,
+                encoding=UTF8_ENCODING,
+                shell=False,
+                text=True,
+            )
+        except OSError as error:
+            search_stderr.write(f"{error}\n")
+            return EXECUTION_ERROR_EXIT_CODE
+        if last_search_run.returncode != ipc_window_not_found_exit_code:
+            search_stdout.write(last_search_run.stdout)
+            search_stderr.write(last_search_run.stderr)
+            return last_search_run.returncode
+        if each_attempt_index < ipc_window_retry_count:
+            time.sleep(ipc_window_retry_delay_seconds)
+    search_stderr.write(ipc_client_did_not_answer_message)
+    return ipc_window_not_found_exit_code
 
 
 def _run_registered_search(

package/.agents/skills/everything-search/scripts/everything_search_command_constants/config/constants.py

@@ -5,6 +5,12 @@ EXECUTABLE_NAME = "es.exe"
 EXECUTION_ERROR_EXIT_CODE = 1
 INFORMATIONAL_ARGUMENT = "-version"
 INVALID_INPUT_EXIT_CODE = 2
+IPC_CLIENT_DID_NOT_ANSWER_MESSAGE = (
+    "Everything IPC client did not answer. Everything service state was not probed.\n"
+)
+IPC_WINDOW_NOT_FOUND_EXIT_CODE = 8
+IPC_WINDOW_RETRY_COUNT = 2
+IPC_WINDOW_RETRY_DELAY_SECONDS = 0.5
 PROJECT_PATHS_FILE_NAME = "project-paths.json"
 REGISTRY_META_KEY = "_meta"
 SEARCH_SCOPE_REQUIRED_MESSAGE = "The first search argument must define a path, project, name, extension, date, or size scope.\n"

package/.agents/skills/everything-search/scripts/test_everything_search.py

@@ -113,12 +113,79 @@ def test_main_passes_through_child_exit_status() -> None:
     with (
         patch.object(search, "load_registry", return_value={}),
         patch.object(search.shutil, "which", return_value="es.exe"),
-        patch.object(search.subprocess, "run", return_value=completed_process),
+        patch.object(
+            search.subprocess, "run", return_value=completed_process
+        ) as run_process,
         patch.object(search.sys, "stderr", captured_stderr),
     ):
         exit_code = search.main(["config.py"])
     assert exit_code == 7
     assert captured_stderr.getvalue() == "failed\n"
+    run_process.assert_called_once()
+
+
+def _ipc_window_error_process() -> search.subprocess.CompletedProcess:
+    return search.subprocess.CompletedProcess(
+        args=["es.exe", "config.py"],
+        returncode=8,
+        stdout="",
+        stderr=(
+            "Error 8: Everything IPC window not found. "
+            "Please make sure Everything is running.\n"
+        ),
+    )
+
+
+def test_main_retries_ipc_window_error_then_returns_search_hits() -> None:
+    successful_process = search.subprocess.CompletedProcess(
+        args=["es.exe", "config.py"],
+        returncode=0,
+        stdout="found path\n",
+        stderr="",
+    )
+    captured_stdout = io.StringIO()
+    captured_stderr = io.StringIO()
+    with (
+        patch.object(search, "load_registry", return_value={}),
+        patch.object(search.shutil, "which", return_value="es.exe"),
+        patch.object(
+            search.subprocess,
+            "run",
+            side_effect=[_ipc_window_error_process(), successful_process],
+        ) as run_process,
+        patch.object(search.sys, "stdout", captured_stdout),
+        patch.object(search.sys, "stderr", captured_stderr),
+        patch("time.sleep"),
+    ):
+        exit_code = search.main(["config.py"])
+    assert exit_code == 0
+    assert captured_stdout.getvalue() == "found path\n"
+    assert "not loaded" not in captured_stderr.getvalue().casefold()
+    assert "not running" not in captured_stderr.getvalue().casefold()
+    assert run_process.call_count == 2
+
+
+def test_main_reports_ipc_client_miss_after_ipc_window_retries_exhaust() -> None:
+    captured_stderr = io.StringIO()
+    with (
+        patch.object(search, "load_registry", return_value={}),
+        patch.object(search.shutil, "which", return_value="es.exe"),
+        patch.object(
+            search.subprocess,
+            "run",
+            return_value=_ipc_window_error_process(),
+        ) as run_process,
+        patch.object(search.sys, "stderr", captured_stderr),
+        patch("time.sleep"),
+    ):
+        exit_code = search.main(["config.py"])
+    assert exit_code == 8
+    stderr_text = captured_stderr.getvalue()
+    assert "Everything IPC client did not answer" in stderr_text
+    assert "service state was not probed" in stderr_text.casefold()
+    assert "Please make sure Everything is running" not in stderr_text
+    assert "not loaded" not in stderr_text.casefold()
+    assert run_process.call_count == 3
 
 
 def test_main_reports_missing_executable() -> None:

package/bin/install.test.mjs

@@ -1353,6 +1353,23 @@ test('mergeHooksIntoSettings is idempotent when run twice against an already-upd
 });
 
 
+test('shipped SessionEnd hook timeouts stay within the Codex runtime limit', () => {
+    const shippedHooksConfig = JSON.parse(
+        readFileSync(new URL('../hooks/hooks.json', import.meta.url), 'utf8')
+    );
+    const allSessionEndHooks = (shippedHooksConfig.hooks.SessionEnd || [])
+        .flatMap(eachMatcherGroup => eachMatcherGroup.hooks);
+
+    assert.ok(allSessionEndHooks.length > 0, 'shipped hooks.json must register SessionEnd hooks');
+    for (const eachSessionEndHook of allSessionEndHooks) {
+        assert.ok(
+            eachSessionEndHook.timeout <= 3,
+            `${eachSessionEndHook.command} exceeds the Codex SessionEnd runtime limit`,
+        );
+    }
+});
+
+
 test('shipped hooks.json keeps only nonblocking policy handlers and lifecycle hooks', () => {
     const shippedHooksConfig = JSON.parse(
         readFileSync(new URL('../hooks/hooks.json', import.meta.url), 'utf8')

package/hooks/blocking/content_search_to_zoekt_redirector.py

@@ -0,0 +1 @@
+"""Retired search hook entrypoint kept inert for stale command references."""

package/hooks/blocking/test_content_search_to_zoekt_redirector.py

@@ -0,0 +1,46 @@
+"""Regression tests for the inert retired search hook entrypoint."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+
+_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+_ENTRYPOINT_PATH = _BLOCKING_DIRECTORY / "content_search_to_zoekt_redirector.py"
+_HOOKS_MANIFEST_PATH = _BLOCKING_DIRECTORY.parent / "hooks.json"
+
+
+def test_retired_entrypoint_allows_valid_search_events_silently() -> None:
+    all_search_events = (
+        {"tool_name": "Bash", "tool_input": {"command": "rg --files packages"}},
+        {
+            "tool_name": "Grep",
+            "tool_input": {"pattern": "zoekt", "path": "packages"},
+        },
+        {
+            "tool_name": "Search",
+            "tool_input": {"pattern": "zoekt", "path": "packages"},
+        },
+    )
+
+    for each_search_event in all_search_events:
+        completed_process = subprocess.run(
+            [sys.executable, str(_ENTRYPOINT_PATH)],
+            check=False,
+            input=json.dumps(each_search_event),
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+        )
+        assert completed_process.returncode == 0
+        assert completed_process.stdout == ""
+        assert completed_process.stderr == ""
+
+
+def test_shipped_hook_manifest_omits_retired_entrypoint() -> None:
+    hooks_manifest_text = _HOOKS_MANIFEST_PATH.read_text(encoding="utf-8")
+
+    assert _ENTRYPOINT_PATH.name not in hooks_manifest_text

package/hooks/hooks.json

@@ -84,12 +84,12 @@
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/lifecycle/session_end_cleanup.py",
-            "timeout": 15
+            "timeout": 3
           },
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/session_edit_tracker_cleanup.py",
-            "timeout": 10
+            "timeout": 3
           }
         ]
       }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "7.2.0",
+    "version": "7.2.1",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/rules/filesystem-search.md

@@ -19,7 +19,7 @@ Three tools are equally sanctioned; pick by what you know:
 | A name or path pattern | The harness `Glob` tool |
 | Text inside files | The harness `Grep` tool |
 
-When `es.exe` fails or returns nothing, fall back to `Glob` or `Grep` without pausing, and report the outage so the reader knows the index was unavailable. Ask the user only after all three tools fail.
+When `es.exe` returns Error 8, retry the same search twice before any fallback. Error 8 is a missing IPC client window, not proof the index is down. After those retries fail, report that the Everything IPC client did not answer and that the service state was not probed, then fall back to `Glob` or `Grep` with the same scope. When `es.exe` is missing, or a later search returns no hits, fall back to `Glob` or `Grep`. Ask the user only after all three tools fail.
 
 `skills/everything-search/SKILL.md` holds the full `es.exe` operator reference: `ext:`, `dm:`, `size:`, wildcards, OR/AND/NOT, output flags, and the junction and drive-mapping note.