Add prompt and command variants of infinite block test

Renamed the original infinite block test to clarify it uses a prompt action,
and added a new command-based variant that uses `false` (always fails).

Both tests verify the promise mechanism:
- Infinite Block Prompt: Shows instructions, promise bypasses
- Infinite Block Command: Runs failing command, promise skips execution

Testing confirmed that promises work correctly for both action types -
when a promise is provided, command-action rules are skipped entirely
and the command never runs.

Author: claude

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

@@ -0,0 +1,41 @@
+---
+name: "Manual Test: Infinite Block Command"
+trigger: manual_tests/test_infinite_block_command/test_infinite_block_command.py
+action:
+  command: "false"
+  run_for: each_match
+compare_to: prompt
+---
+
+# Manual Test: Infinite Block Command (Promise Required)
+
+This rule runs a command that ALWAYS FAILS (`false` returns exit code 1).
+
+## Why this blocks
+
+The command action always fails, creating an infinite block. The only way
+to proceed should be to provide a promise acknowledging that you understand
+the restriction.
+
+## Expected behavior
+
+If promises work correctly for command actions:
+- Without promise: Command runs, fails, blocks
+- With promise: Command is SKIPPED entirely, allows
+
+If there's a bug:
+- The command will run and fail even when a promise is provided
+
+## What to do
+
+You MUST include the following promise tag in your response:
+
+```
+<promise>Manual Test: Infinite Block Command</promise>
+```
+
+## This tests
+
+Whether the promise mechanism works for COMMAND-type rules. If a rule is
+promised, the command should not run at all - the rule should be skipped
+during evaluation.

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

@@ -0,0 +1,34 @@
+---
+name: "Manual Test: Infinite Block Prompt"
+trigger: manual_tests/test_infinite_block_prompt/test_infinite_block_prompt.py
+compare_to: prompt
+---
+
+# Manual Test: Infinite Block Prompt (Promise Required)
+
+You edited `{trigger_files}` which triggers an infinite block.
+
+## Why this blocks
+
+This rule has NO safety file option and uses a PROMPT action. 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 Prompt</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 PROMPT-type rules that cannot be satisfied by
+editing additional files. This is useful for enforcing policies where
+acknowledgment is the only valid response.

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

@@ -34,7 +34,8 @@ 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 |
+| **Infinite Block Prompt** | Edit `.py` (always blocks) | Provide `<promise>` tag | Manual Test: Infinite Block Prompt |
+| **Infinite Block Command** | Edit `.py` (command fails) | Provide `<promise>` tag | Manual Test: Infinite Block Command |
 
 ## Test Results Tracking
 
@@ -46,7 +47,8 @@ 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 | ☐ | ☐ |
+| Infinite Block Prompt | ☐ | ☐ |
+| Infinite Block Command | ☐ | ☐ |
 
 ## Test Folders
 
@@ -57,7 +59,8 @@ 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 |
+| `test_infinite_block_prompt/` | Infinite Block (Prompt) | Always blocks with prompt; only promise can bypass |
+| `test_infinite_block_command/` | Infinite Block (Command) | Command always fails; tests if promise skips command |
 
 ## Corresponding Rules
 
@@ -67,4 +70,5 @@ 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-test-infinite-block-prompt.md`
+- `manual-test-infinite-block-command.md`

manual_tests/README.md

@@ -0,0 +1,56 @@
+"""
+MANUAL TEST: Infinite Block Command Rule (Promise Required)
+
+=== WHAT THIS TESTS ===
+Tests a COMMAND-type rule with a command that ALWAYS FAILS - it will ALWAYS
+block when the trigger file is edited. This tests whether the promise mechanism
+works for command-action rules.
+
+This verifies:
+1. The rule correctly blocks when the file is edited (command fails)
+2. The promise mechanism should bypass the command entirely
+3. The promise must be in the exact format: <promise>Rule Name</promise>
+
+=== TEST CASE 1: Rule SHOULD fire (command fails, infinite block) ===
+1. Edit this file (add a comment below the marker)
+2. Run: echo '{}' | python -m deepwork.hooks.rules_check
+3. Expected: Block with command error - the `false` command always fails
+
+=== 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 Command</promise>
+3. Run the hook with the transcript
+4. Expected: Empty JSON {} (allow) - promise should bypass the command entirely
+
+=== 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 Command</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)
+   If NOT empty: BUG - promises don't work for command-action rules!
+
+=== RULE LOCATION ===
+.deepwork/rules/manual-test-infinite-block-command.md
+
+=== KEY DIFFERENCE FROM PROMPT VERSION ===
+- Prompt version: Shows instructions, agent must respond with promise
+- Command version: Runs a command that always fails, promise should skip it
+
+If the promise mechanism doesn't work for command rules, this test will reveal
+that bug - the command will still run and fail even when a promise is provided.
+"""
+
+
+def restricted_command_operation():
+    """An operation that requires explicit acknowledgment to proceed."""
+    return "This operation uses a command that always fails"
+
+
+# Edit below this line to trigger the rule
+# -------------------------------------------
+# Test edit for command block

manual_tests/test_infinite_block_command/test_infinite_block_command.py

@@ -1,10 +1,10 @@
 """
-MANUAL TEST: Infinite Block Rule (Promise Required)
+MANUAL TEST: Infinite Block Prompt 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.
+Tests a PROMPT-type 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
@@ -14,34 +14,37 @@
 === 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"
+3. Expected: "Manual Test: Infinite Block Prompt" 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>
+2. Create a transcript with: <promise>Manual Test: Infinite Block Prompt</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
+   echo '{"role":"assistant","message":{"content":[{"type":"text","text":"<promise>Manual Test: Infinite Block Prompt</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
+.deepwork/rules/manual-test-infinite-block-prompt.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.
+
+=== COMPARISON WITH COMMAND VERSION ===
+See test_infinite_block_command/ for the command-action version of this test.
 """