claude-dev-env 8.73.1 → 8.74.0

package/hooks/blocking/artifact_look_gate.py

@@ -1,223 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: refuse to publish an artifact page nobody has looked at.
-
-An agent that writes a page and publishes it without rendering it cannot know
-the page matches the ask. The hook walks the session transcript and allows the
-publish only when a Read opened an image file whose modification time is at
-least the page file's::
-
-    Write page.html -> shoot shot.png -> Read shot.png -> publish -> allowed
-    Write page.html -> publish                                    -> refused
-    Read shot.png -> change page.html in any tool -> publish      -> refused
-    Read an image older than the page -> publish                  -> refused
-
-A Read that returned an error, or whose result came before the page's last
-change, does not count. A non-HTML file, an asset
-upload, a non-publish action and an unreadable transcript all pass, so the
-hook never fails closed.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-from datetime import datetime
-from pathlib import Path
-
-hooks_root_directory = str(Path(__file__).resolve().parent.parent)
-if hooks_root_directory not in sys.path:
-    sys.path.insert(0, hooks_root_directory)
-
-from hooks_constants.artifact_look_gate_constants import (
-    ALL_IMAGE_FILE_SUFFIXES,
-    ALL_PAGE_FILE_SUFFIXES,
-    ARTIFACT_ACTION_INPUT_KEY,
-    ARTIFACT_ASSET_INPUT_KEY,
-    ARTIFACT_PUBLISH_ACTION,
-    ARTIFACT_TOOL_NAME,
-    ASSISTANT_ENTRY_TYPE,
-    DENY_DECISION,
-    ENTRY_TIMESTAMP_KEY,
-    FILE_PATH_INPUT_KEY,
-    IMAGE_READING_TOOL_NAME,
-    PRE_TOOL_USE_EVENT_NAME,
-    TOOL_INPUT_KEY,
-    TOOL_NAME_KEY,
-    TOOL_RESULT_BLOCK_TYPE,
-    TOOL_USE_BLOCK_TYPE,
-    TRANSCRIPT_DECODE_ERRORS,
-    TRANSCRIPT_ENCODING,
-    TRANSCRIPT_PATH_KEY,
-    UNSEEN_PAGE_REASON_TEMPLATE,
-    USER_ENTRY_TYPE,
-)
-from hooks_constants.hook_specific_output_keys import (
-    HOOK_EVENT_NAME_KEY,
-    HOOK_SPECIFIC_OUTPUT_KEY,
-    PERMISSION_DECISION_KEY,
-)
-from hooks_constants.pr_lifecycle_skill_gate_constants import (
-    PERMISSION_DECISION_REASON_KEY,
-)
-from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
-
-
-def _content_blocks(
-    all_entry_fields: dict[str, object], entry_type: str
-) -> list[dict[str, object]]:
-    if all_entry_fields.get("type") != entry_type:
-        return []
-    message = all_entry_fields.get("message")
-    content = message.get("content") if isinstance(message, dict) else None
-    if not isinstance(content, list):
-        return []
-    return [each_block for each_block in content if isinstance(each_block, dict)]
-
-
-def _parsed_entry(transcript_line: str) -> dict[str, object]:
-    try:
-        parsed_line = json.loads(transcript_line)
-    except json.JSONDecodeError:
-        return {}
-    return parsed_line if isinstance(parsed_line, dict) else {}
-
-
-def _entry_epoch(all_entry_fields: dict[str, object]) -> float | None:
-    timestamp_text = all_entry_fields.get(ENTRY_TIMESTAMP_KEY)
-    if not isinstance(timestamp_text, str):
-        return None
-    try:
-        return datetime.fromisoformat(timestamp_text.replace("Z", "+00:00")).timestamp()
-    except ValueError:
-        return None
-
-
-def _successful_result_epochs(all_entries: list[dict[str, object]]) -> dict[str, float]:
-    return {
-        str(each_block.get("tool_use_id")): result_epoch
-        for each_entry in all_entries
-        if (result_epoch := _entry_epoch(each_entry)) is not None
-        for each_block in _content_blocks(each_entry, USER_ENTRY_TYPE)
-        if each_block.get("type") == TOOL_RESULT_BLOCK_TYPE and not each_block.get("is_error")
-    }
-
-
-def _tool_calls(all_entries: list[dict[str, object]]) -> list[tuple[str, object, object]]:
-    return [
-        (str(each_block.get("id")), each_block.get("name"), tool_input.get(FILE_PATH_INPUT_KEY))
-        for each_entry in all_entries
-        for each_block in _content_blocks(each_entry, ASSISTANT_ENTRY_TYPE)
-        if each_block.get("type") == TOOL_USE_BLOCK_TYPE
-        and isinstance(tool_input := each_block.get("input"), dict)
-    ]
-
-
-def _is_image_read(tool_name: object, file_path: object) -> bool:
-    return (
-        tool_name == IMAGE_READING_TOOL_NAME
-        and isinstance(file_path, str)
-        and file_path.lower().endswith(ALL_IMAGE_FILE_SUFFIXES)
-    )
-
-
-def _modified_time(file_path: str) -> float | None:
-    try:
-        return Path(file_path).stat().st_mtime
-    except OSError:
-        return None
-
-
-def page_was_looked_at(all_transcript_lines: list[str], page_path: str) -> bool:
-    """Return True when a screenshot made after the page's last change was read.
-
-    The page's modification time covers every way it can change, including a
-    Bash command or a subagent. A Read counts only when it succeeded, its
-    result arrived after the page last changed, and its image file is at
-    least as new as the page.
-
-    Args:
-        all_transcript_lines: The session transcript, one JSON record per line.
-        page_path: The file the Artifact call publishes.
-    """
-    page_modified_time = _modified_time(page_path)
-    if page_modified_time is None:
-        return False
-    all_entries = [_parsed_entry(each_line) for each_line in all_transcript_lines]
-    result_epoch_by_id = _successful_result_epochs(all_entries)
-    for each_id, each_tool_name, each_file_path in _tool_calls(all_entries):
-        result_epoch = result_epoch_by_id.get(each_id)
-        if not _is_image_read(each_tool_name, each_file_path) or result_epoch is None:
-            continue
-        image_modified_time = _modified_time(str(each_file_path))
-        if (
-            image_modified_time is not None
-            and image_modified_time >= page_modified_time
-            and result_epoch >= page_modified_time
-        ):
-            return True
-    return False
-
-
-def _published_page_path(all_hook_fields: dict[str, object]) -> str | None:
-    tool_input = all_hook_fields.get(TOOL_INPUT_KEY)
-    if all_hook_fields.get(TOOL_NAME_KEY) != ARTIFACT_TOOL_NAME or not isinstance(tool_input, dict):
-        return None
-    page_path = tool_input.get(FILE_PATH_INPUT_KEY)
-    is_page_publish = (
-        tool_input.get(ARTIFACT_ACTION_INPUT_KEY, ARTIFACT_PUBLISH_ACTION) == ARTIFACT_PUBLISH_ACTION
-        and tool_input.get(ARTIFACT_ASSET_INPUT_KEY) is not True
-        and isinstance(page_path, str)
-        and page_path.lower().endswith(ALL_PAGE_FILE_SUFFIXES)
-    )
-    return page_path if is_page_publish else None
-
-
-def unseen_page_reason(all_hook_fields: dict[str, object]) -> str | None:
-    """Return the refusal for an unseen page publish, or None to allow it.
-
-    Args:
-        all_hook_fields: The parsed PreToolUse payload.
-    """
-    page_path = _published_page_path(all_hook_fields)
-    transcript_path = all_hook_fields.get(TRANSCRIPT_PATH_KEY)
-    if page_path is None or not isinstance(transcript_path, str):
-        return None
-    try:
-        all_transcript_lines = Path(transcript_path).read_text(
-            encoding=TRANSCRIPT_ENCODING, errors=TRANSCRIPT_DECODE_ERRORS
-        ).splitlines()
-    except OSError:
-        return None
-    if page_was_looked_at(all_transcript_lines, page_path):
-        return None
-    return UNSEEN_PAGE_REASON_TEMPLATE.format(page_path=page_path)
-
-
-def main() -> int:
-    """Read the PreToolUse payload and print a deny decision for an unseen page.
-
-    Returns:
-        0 in every case; the decision travels in the JSON output.
-    """
-    hook_payload = read_hook_input_dictionary_from_stdin()
-    if hook_payload is None:
-        return 0
-    refusal_reason = unseen_page_reason(hook_payload)
-    if refusal_reason is not None:
-        sys.stdout.write(
-            json.dumps(
-                {
-                    HOOK_SPECIFIC_OUTPUT_KEY: {
-                        HOOK_EVENT_NAME_KEY: PRE_TOOL_USE_EVENT_NAME,
-                        PERMISSION_DECISION_KEY: DENY_DECISION,
-                        PERMISSION_DECISION_REASON_KEY: refusal_reason,
-                    }
-                }
-            )
-        )
-        sys.stdout.flush()
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/hooks/blocking/test_artifact_look_gate.py

@@ -1,153 +0,0 @@
-"""Behavior tests for the artifact look gate.
-
-The refused case replays a session that wrote a page and published it with no
-render in between, the way a text-card page reached the person who asked for
-a diagram.
-"""
-
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-_BLOCKING_DIR = Path(__file__).resolve().parent
-_HOOKS_ROOT = _BLOCKING_DIR.parent
-for each_sys_path_entry in (str(_BLOCKING_DIR), str(_HOOKS_ROOT)):
-    if each_sys_path_entry not in sys.path:
-        sys.path.insert(0, each_sys_path_entry)
-
-import artifact_look_gate
-
-HOOK_SCRIPT = _BLOCKING_DIR / "artifact_look_gate.py"
-
-
-def _tool_use(call_id: str, tool_name: str, file_path: str) -> dict[str, object]:
-    return {
-        "type": "assistant",
-        "message": {
-            "content": [
-                {
-                    "type": "tool_use",
-                    "id": call_id,
-                    "name": tool_name,
-                    "input": {"file_path": file_path},
-                }
-            ]
-        },
-    }
-
-
-def _tool_result(
-    call_id: str, is_error: bool = False, timestamp: str = "2026-01-01T00:00:00Z"
-) -> dict[str, object]:
-    return {
-        "type": "user",
-        "timestamp": timestamp,
-        "message": {
-            "content": [
-                {
-                    "type": "tool_result",
-                    "tool_use_id": call_id,
-                    "content": "ok",
-                    "is_error": is_error,
-                }
-            ]
-        },
-    }
-
-
-def _run_hook(tmp_path: Path, all_records: list[dict[str, object]], page_path: Path) -> str:
-    transcript_path = tmp_path / "transcript.jsonl"
-    transcript_path.write_text(
-        "".join(json.dumps(each_record) + "\n" for each_record in all_records), encoding="utf-8"
-    )
-    completed = subprocess.run(
-        [sys.executable, str(HOOK_SCRIPT)],
-        input=json.dumps(
-            {
-                "hook_event_name": "PreToolUse",
-                "tool_name": "Artifact",
-                "tool_input": {"file_path": str(page_path), "icon": "map"},
-                "transcript_path": str(transcript_path),
-            }
-        ),
-        capture_output=True,
-        text=True,
-        check=True,
-    )
-    return completed.stdout
-
-
-def _file_at(file_path: Path, modified_time: float) -> Path:
-    file_path.write_text("x", encoding="utf-8")
-    os.utime(file_path, (modified_time, modified_time))
-    return file_path
-
-
-def _read_records(
-    image_path: Path, is_error: bool = False, timestamp: str = "2026-01-01T00:00:00Z"
-) -> list[dict[str, object]]:
-    return [_tool_use("r1", "Read", str(image_path)), _tool_result("r1", is_error, timestamp)]
-
-
-def test_should_refuse_a_page_published_without_a_look(tmp_path: Path) -> None:
-    page_path = _file_at(tmp_path / "page.html", 1000)
-    hook_output = json.loads(
-        _run_hook(
-            tmp_path, [_tool_use("w1", "Write", str(page_path)), _tool_result("w1")], page_path
-        )
-    )
-    specific_output = hook_output["hookSpecificOutput"]
-    assert specific_output["permissionDecision"] == "deny"
-    assert "--screenshot" in specific_output["permissionDecisionReason"]
-    assert "Attach" not in specific_output["permissionDecisionReason"]
-
-
-def test_should_allow_a_page_whose_newer_screenshot_was_read(tmp_path: Path) -> None:
-    page_path = _file_at(tmp_path / "page.html", 1000)
-    image_path = _file_at(tmp_path / "page.png", 1001)
-    assert _run_hook(tmp_path, _read_records(image_path), page_path) == ""
-
-
-def test_should_refuse_when_the_page_changed_after_the_screenshot(tmp_path: Path) -> None:
-    image_path = _file_at(tmp_path / "page.png", 1000)
-    page_path = _file_at(tmp_path / "page.html", 1001)
-    assert "deny" in _run_hook(tmp_path, _read_records(image_path), page_path)
-
-
-def test_should_refuse_when_the_screenshot_read_failed(tmp_path: Path) -> None:
-    page_path = _file_at(tmp_path / "page.html", 1000)
-    image_path = _file_at(tmp_path / "page.png", 1001)
-    assert "deny" in _run_hook(tmp_path, _read_records(image_path, is_error=True), page_path)
-
-
-def test_should_refuse_a_screenshot_overwritten_after_its_read(tmp_path: Path) -> None:
-    page_path = _file_at(tmp_path / "page.html", 1000)
-    image_path = _file_at(tmp_path / "page.png", 1001)
-    read_before_the_page_changed = "1970-01-01T00:16:39Z"
-    assert "deny" in _run_hook(
-        tmp_path, _read_records(image_path, timestamp=read_before_the_page_changed), page_path
-    )
-
-
-def test_page_was_looked_at_ignores_reads_of_other_files(tmp_path: Path) -> None:
-    page_path = _file_at(tmp_path / "page.html", 1000)
-    notes_path = _file_at(tmp_path / "notes.md", 1001)
-    all_lines = [json.dumps(each_record) for each_record in _read_records(notes_path)]
-    assert not artifact_look_gate.page_was_looked_at(all_lines, str(page_path))
-
-
-def test_unseen_page_reason_passes_non_publish_calls() -> None:
-    assert (
-        artifact_look_gate.unseen_page_reason(
-            {"tool_name": "Artifact", "tool_input": {"action": "read", "url": "x"}}
-        )
-        is None
-    )
-    assert (
-        artifact_look_gate.unseen_page_reason(
-            {"tool_name": "Artifact", "tool_input": {"file_path": "image.png", "asset": True}}
-        )
-        is None
-    )

package/hooks/hooks_constants/artifact_look_gate_constants.py

@@ -1,32 +0,0 @@
-"""Names and refusal text for the artifact_look_gate PreToolUse hook."""
-
-from __future__ import annotations
-
-ARTIFACT_TOOL_NAME = "Artifact"
-ARTIFACT_ACTION_INPUT_KEY = "action"
-ARTIFACT_PUBLISH_ACTION = "publish"
-ARTIFACT_ASSET_INPUT_KEY = "asset"
-FILE_PATH_INPUT_KEY = "file_path"
-TOOL_NAME_KEY = "tool_name"
-TOOL_INPUT_KEY = "tool_input"
-TRANSCRIPT_PATH_KEY = "transcript_path"
-IMAGE_READING_TOOL_NAME = "Read"
-ALL_IMAGE_FILE_SUFFIXES = (".png", ".jpg", ".jpeg", ".webp", ".gif")
-ALL_PAGE_FILE_SUFFIXES = (".html", ".htm")
-TRANSCRIPT_ENCODING = "utf-8"
-TRANSCRIPT_DECODE_ERRORS = "replace"
-ASSISTANT_ENTRY_TYPE = "assistant"
-USER_ENTRY_TYPE = "user"
-TOOL_USE_BLOCK_TYPE = "tool_use"
-TOOL_RESULT_BLOCK_TYPE = "tool_result"
-ENTRY_TIMESTAMP_KEY = "timestamp"
-PRE_TOOL_USE_EVENT_NAME = "PreToolUse"
-DENY_DECISION = "deny"
-UNSEEN_PAGE_REASON_TEMPLATE = (
-    "This page has not been looked at since it was last written. Render it "
-    "and look at the picture before you publish: take a screenshot with a "
-    "headless browser, for example `chromium --headless --screenshot=page.png "
-    "--window-size=800,900 file://{page_path}`, then open page.png with the "
-    "Read tool and check it against the ask. Fix what the picture shows, take "
-    "a new screenshot, and publish again."
-)

package/rules/asd-ste100-language.md

@@ -1,9 +0,0 @@
-# ASD-STE100 language policy
-
-**When:** Writing chat, tool narration, or repository prose.
-
-Use the sole general language rule. Write short, complete sentences on one topic. Use active voice; lead with conditions; one action per step. Use plain, precise words, stable terms. Expand abbreviations and contractions; name unclear pronouns. Be inclusive; punctuate clearly. Preserve exact labels, identifiers, formulas, titles, interface text. Say each fact once. Send a result, blocker, or question. Mark injury or death `WARNING`, equipment damage `CAUTION`; state condition then result. Aim for 20 words per step, 25 per description. Treat checks as aids; have a human verify accuracy, terms, safety, confidentiality, meaning.
-
-**Enforcement:** none.
-
-**Full text:** [guide](../docs/rule-guides/asd-ste100-language.md). Read it for sources.

package/rules/cleanup-temp-files.md

@@ -1,9 +0,0 @@
-# Clean up temporary files
-
-**When:** Creating scratch files, debug dumps, or one-off helpers during a task.
-
-Prefer memory to scratch files and track any temporary files you create. At completion, remove those files and leave user-requested files in place. Files under the OS temporary root or `$CLAUDE_JOB_DIR` need no explicit removal; a parent handles child-agent scratch.
-
-**Enforcement:** none.
-
-**Full text:** [guide](../docs/rule-guides/cleanup-temp-files.md). Read it to classify a file or choose cleanup.

package/rules/destructive-commands.md

@@ -1,11 +0,0 @@
-# Destructive commands in Bash
-
-**When:** Removing files or writing a destructive command string.
-
-Keep destructive literals out of command strings, including data. Use literal absolute targets; never target a bare temporary root. Use `git rm` for tracked files. Pass bodies by file and test hooks through the test suite. Copy this line into every subagent prompt:
-
-> Never use bash rm in any form. Delete scratch/probe files with the PowerShell tool (Remove-Item -Recurse -Force -Confirm:$false <absolute path>), or leave them in the OS temp dir; remove worktrees only via git worktree remove --force.
-
-**Enforcement:** none; a harness permission prompt can stall unattended work.
-
-**Full text:** [guide](../docs/rule-guides/destructive-commands.md). Read it before any removal.

package/rules/explore-thoroughly.md

@@ -1,9 +0,0 @@
-# Explore thoroughly
-
-**When:** Before you log, plan, delegate, or build an ask, or choose an approach.
-
-Search for what already does the ask, in full or in part. When something exists, stop and report it to the user in four points; run the `search-before-acting` skill. Then read files, patterns, and constraints, scaled to risk. Once the files, constraints, and success condition are known, act without repeating settled research.
-
-**Enforcement:** the pull request gate denies a body with no "Existing work" section.
-
-**Full text:** [guide](../docs/rule-guides/explore-thoroughly.md). Read it for search scope and depth.

package/rules/features-start-with-an-eval.md

@@ -1,9 +0,0 @@
-# Features start with an eval
-
-**When:** A user asks for a new feature or a change in behavior.
-
-Your first action is the Skill tool with skill `claude-api` and args `build-eval`. Build the feature against that eval. When the work touches an existing feature with no eval, start a separate session to build that eval in parallel. An Agent-tool subagent does not count. You own its result.
-
-**Enforcement:** `hooks/blocking/pr_lifecycle_skill_gate.py` denies a `feat` pull request with no "Eval" section or no build-eval call.
-
-**Full text:** [guide](../docs/rule-guides/features-start-with-an-eval.md).

package/rules/filesystem-search.md

@@ -1,9 +0,0 @@
-# Filesystem search
-
-**When:** Searching for files by name, path, extension, size, or date.
-
-Scope every search to a project, worktree, package, or narrowing filter. Never start at a filesystem root, drive root, bare home, or share root. Read a known path directly; use scoped `es.exe`, Glob, or Grep for discovery. After `es.exe` Error 8, retry twice before falling back within the same scope. Run one large shell walk at a time.
-
-**Enforcement:** none.
-
-**Full text:** [guide](../docs/rule-guides/filesystem-search.md). Read it for tool selection and search examples.

package/rules/memory-stores-durable-facts.md

@@ -1,9 +0,0 @@
-# Memory stores durable facts
-
-**When:** Writing auto-memory or adding a `MEMORY.md` entry.
-
-Keep only a fact that helps a fresh session weeks later. Remove dates, task identifiers, commits, and paths from a draft; if the remainder is empty or false, put it in the task tracker or handoff instead. Store standing user preferences, stable setup traps, and useful resource pointers. Delete stale memory and its index line in the same run.
-
-**Enforcement:** none.
-
-**Full text:** [guide](../docs/rule-guides/memory-stores-durable-facts.md). Read it when deciding whether a fact belongs in memory.

package/rules/no-contrast-framing.md

@@ -1,9 +0,0 @@
-# No contrast framing
-
-**When:** Writing any sentence a person reads.
-
-State the chosen point directly and leave out the discarded reading. Remove these six forms: `trailing-comma-not`, `corrective-it-is-not`, `substitution-rather-than`, `additive-not-just`, `comparative-ranking`, `substitution-as-opposed-to`. Keep quantity comparisons. If a sentence loses substance, add the failing check, log line, measured number, or file and line.
-
-**Enforcement:** staged policy lint and `scripts/durable_post_lint.py` check authored text; the agent checks chat.
-
-**Full text:** [guide](../docs/rule-guides/no-contrast-framing.md). Read it for examples and checker exceptions.

package/rules/proof-before-pull-request.md

@@ -1,7 +0,0 @@
-# Proof before a pull request
-
-**When:** Before you open a pull request.
-
-Run the change where it runs, with and without it, and quote both results under "Proof in practice" in the body. A hook denies a body without one. Unproven: leave it unopened and tell the user.
-
-**Full text:** [guide](../docs/rule-guides/proof-before-pull-request.md).

package/rules/request-scope.md

@@ -1,7 +0,0 @@
-# Request scope
-
-**When:** Asked whether part of a block is still needed, or asked to change one.
-
-A shipped gate makes each block line restating what it enforces dead text. Propose removing all of them, past the part asked about, and give each kept line's reason. Read the output back before reporting done.
-
-**Full text:** [guide](../docs/rule-guides/request-scope.md)

package/rules/research-mode.md

@@ -1,9 +0,0 @@
-# Research mode
-
-**When:** Making a factual claim, recommendation, or piece of advice.
-
-State no claim without a credible source; do not guess or infer. Before an answer depends on an unsettled fact, run each tool that could settle it and that reads state or that permissions already allow, and stop at the first one that settles it. When none can, name the exact check and who can run or approve it. Cite a project file, web source, named expert or paper, or official documentation for each claim. Retract claims a source cannot support. Extract document text before analysis and ground the answer in word-for-word quotes. In chat, cite compactly with a link or `file:line`; put full quotes and citation lists in artifacts or replies that request them. Ground synthesis in sourced inputs. Creative ideas need no citation.
-
-**Enforcement:** none.
-
-**Full text:** [guide](../docs/rule-guides/research-mode.md). Read it when checking a source or citation.

package/rules/session-title.md

@@ -1,9 +0,0 @@
-# Status in the session title
-
-**When:** The session has a tool whose name ends in `__set_session_title`.
-
-Before each turn ends, set the title to `<emoji> <name>`. Use the red flag when the user must act, the check mark when the work is done, and the hourglass while work, CI, or a merge queue runs. The name has 25 characters or fewer, in sentence case, with concrete nouns and no IDs, dates, or branch names.
-
-**Enforcement:** `hooks/blocking/session_title_format_gate.py` denies a malformed title; `hooks/blocking/session_title_stop_gate.py` blocks a turn end with no title.
-
-**Full text:** [guide](../docs/rule-guides/session-title.md). Read it for the emoji table and naming rules.

package/rules/shell-invocation.md

@@ -1,9 +0,0 @@
-# Shell invocation
-
-**When:** Issuing a Bash-tool shell command, or writing a `settings.json` permission rule.
-
-On Windows, run shell work through `pwsh`: `pwsh -NoProfile -File '<script>.ps1' <args>` for a script, and `pwsh -NoProfile -Command "..."` or the `PowerShell` tool for inline work. A direct interpreter call such as `python script.py` conforms as written. Keep `powershell`, `cmd /c`, and `bash -c` out of permission rules. Keep `$(...)`, unescaped backticks, and `<(...)` or `>(...)` out of Bash commands; split the call or use a flag form such as `git -C "<path>"`. Arithmetic `$((...))` passes.
-
-**Enforcement:** none; a permission prompt on a wrapped command is the signal. `blocking/msys_rev_path_rewriter.py` only rewrites a `<rev>:<path>` argument.
-
-**Full text:** [guide](../docs/rule-guides/shell-invocation.md). Read it before writing a permission rule or a multi-step shell command.

package/rules/skill-pointers.md

@@ -1,3 +0,0 @@
-# Pull request lifecycle skill
-
-Before a commit, a push, a pull request action or a merge, invoke the `pr-lifecycle` skill; a PreToolUse hook denies those commands until it loads.

package/rules/verify-before-asking.md

@@ -1,9 +0,0 @@
-# Verify before asking
-
-**When:** Before asking the user a clarifying question.
-
-Inspect files, directories, configuration, environment, databases, and available tools for the answer. Recheck facts recalled from earlier sessions. Apply any criterion the user already supplied and state the decision. Ask only for a judgment, preference, or inaccessible fact.
-
-**Enforcement:** none.
-
-**Full text:** [guide](../docs/rule-guides/verify-before-asking.md). Read it when the source of an answer is uncertain.

package/rules/verify-runtime-state.md

@@ -1,9 +0,0 @@
-# Verify runtime state
-
-**When:** Before saying a component works, is healthy, or is not the cause of a failure.
-
-Gather a live signal this session: process list, port probe, log, status code, or fresh reproduction. Read the user's terminal and named error log while a reported failure is still visible. Check the effect the work should produce, including each job result, loaded config, or deployed artifact; a success status alone does not establish the effect. When testing code, identify the loaded module path.
-
-**Enforcement:** none.
-
-**Full text:** [guide](../docs/rule-guides/verify-runtime-state.md). Read it when choosing the probe for a claim.