Add manual test for infinite block scenario

This test verifies that a rule with no safety file option will always
block when its trigger file is edited. The only way to proceed is by
providing a promise tag in the correct format:
<promise>Manual Test: Infinite Block</promise>

This tests the promise mechanism for rules that cannot be satisfied by
editing additional files, useful for enforcing policies where explicit
acknowledgment is the only valid response.

Author: claude

.deepwork/rules/manual-test-infinite-block.md

@@ -0,0 +1,33 @@
+---
+name: "Manual Test: Infinite Block"
+trigger: manual_tests/test_infinite_block/test_infinite_block.py
+compare_to: prompt
+---
+
+# Manual Test: Infinite Block (Promise Required)
+
+You edited `{trigger_files}` which triggers an infinite block.
+
+## Why this blocks
+
+This rule has NO safety file option. The only way to proceed is to provide
+a promise acknowledging that you understand the restriction.
+
+## What to do
+
+You MUST include the following promise tag in your response:
+
+```
+<promise>Manual Test: Infinite Block</promise>
+```
+
+This simulates scenarios where:
+- An operation requires explicit acknowledgment before proceeding
+- There is no alternative action that can suppress the rule
+- The agent must demonstrate understanding of the constraint
+
+## This tests
+
+The promise mechanism for rules that cannot be satisfied by editing additional
+files. This is useful for enforcing policies where acknowledgment is the only
+valid response.

manual_tests/README.md

@@ -34,6 +34,7 @@ Each test has two cases: one where the rule SHOULD fire, and one where it should
 | **Pair Mode (reverse)** | — | Edit `_expected.md` only (should NOT fire) | Manual Test: Pair Mode |
 | **Command Action** | Edit `.txt` → log appended | — (always runs) | Manual Test: Command Action |
 | **Multi Safety** | Edit `.py` only | Edit `.py` AND any safety file | Manual Test: Multi Safety |
+| **Infinite Block** | Edit `.py` (always blocks) | Provide `<promise>` tag | Manual Test: Infinite Block |
 
 ## Test Results Tracking
 
@@ -45,6 +46,7 @@ Each test has two cases: one where the rule SHOULD fire, and one where it should
 | Pair Mode (reverse - expected only) | — | ☐ |
 | Command Action | ☐ | — |
 | Multi Safety | ☐ | ☐ |
+| Infinite Block | ☐ | ☐ |
 
 ## Test Folders
 
@@ -55,6 +57,7 @@ Each test has two cases: one where the rule SHOULD fire, and one where it should
 | `test_pair_mode/` | Pair (Directional) | One-way: trigger requires expected, but not vice versa |
 | `test_command_action/` | Command Action | Automatically runs command on file change |
 | `test_multi_safety/` | Multiple Safety | Fires unless ANY of the safety files also edited |
+| `test_infinite_block/` | Infinite Block | Always blocks; only promise can bypass |
 
 ## Corresponding Rules
 
@@ -64,3 +67,4 @@ Rules are defined in `.deepwork/rules/`:
 - `manual-test-pair-mode.md`
 - `manual-test-command-action.md`
 - `manual-test-multi-safety.md`
+- `manual-test-infinite-block.md`

manual_tests/test_infinite_block/test_infinite_block.py

@@ -0,0 +1,54 @@
+"""
+MANUAL TEST: Infinite Block Rule (Promise Required)
+
+=== WHAT THIS TESTS ===
+Tests a rule with NO safety file option - it will ALWAYS block when the
+trigger file is edited. The only way to proceed is to provide a promise
+in the correct format.
+
+This verifies:
+1. The rule correctly blocks when the file is edited
+2. The promise mechanism works to bypass the block
+3. The promise must be in the exact format: <promise>Rule Name</promise>
+
+=== TEST CASE 1: Rule SHOULD fire (infinite block) ===
+1. Edit this file (add a comment below the marker)
+2. Run: echo '{}' | python -m deepwork.hooks.rules_check
+3. Expected: "Manual Test: Infinite Block" appears in output with decision="block"
+4. The block message should explain that a promise is required
+
+=== TEST CASE 2: Rule should NOT fire (promise provided) ===
+1. Edit this file (add a comment below the marker)
+2. Create a transcript with: <promise>Manual Test: Infinite Block</promise>
+3. Run the hook with the transcript
+4. Expected: Empty JSON {} (allow) - promise bypasses the block
+
+=== HOW TO TEST WITH PROMISE ===
+The promise must be in the conversation transcript. To test:
+
+1. Create a temp transcript file with the promise:
+   echo '{"role":"assistant","message":{"content":[{"type":"text","text":"<promise>Manual Test: Infinite Block</promise>"}]}}' > /tmp/transcript.jsonl
+
+2. Run with transcript:
+   echo '{"transcript_path":"/tmp/transcript.jsonl"}' | python -m deepwork.hooks.rules_check
+
+3. Expected: {} (empty JSON = allow)
+
+=== RULE LOCATION ===
+.deepwork/rules/manual-test-infinite-block.md
+
+=== KEY DIFFERENCE FROM OTHER TESTS ===
+Other tests have a "safety" file that can be edited to suppress the rule.
+This test has NO safety option - the ONLY way to proceed is with a promise.
+This simulates scenarios where the agent must explicitly acknowledge a
+constraint before proceeding.
+"""
+
+
+def restricted_operation():
+    """An operation that requires explicit acknowledgment to proceed."""
+    return "This operation always requires a promise to proceed"
+
+
+# Edit below this line to trigger the rule
+# -------------------------------------------