manual_tests.infinite_block_tests

Run four infinite-block tests in strict order with sub-agents.

49|3|Updated Jan 11, 2026
One-click install
npx skills add https://github.com/Unsupervisedcom/deepwork --skill manual-tests-infinite-block-tests
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: manual_tests.infinite_block_tests
Source: https://github.com/Unsupervisedcom/deepwork/tree/main/.claude/skills/manual_tests.infinite_block_tests
Command: npx skills add https://github.com/Unsupervisedcom/deepwork --skill manual-tests-infinite-block-tests

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill orchestrates and validates a complete set of infinite-block tests by delegating work to sub-agents, ensuring deterministic blocking behavior is observable and verifiable.

Core Features & Use Cases

  • Serial test execution: Runs four infinite-block scenarios in strict order with per-test resets to prevent cross-test interference.
  • Promise and non-promise handling: Verifies both bypass (with promise) and blocking (no promise) behaviors, recording queue outcomes.
  • Observability: Captures hook activity and queue status to confirm correct firing and timing, producing an infinite_block_results artifact.

Quick Start

  1. Spawn a sub-agent to run the next test with model: haiku and max_turns: 5, observe the blocking behavior, and record results in the queue.
  2. After each test, perform the mandatory reset and check the rules queue for status entries.
  3. Repeat until all four tests have been executed and results saved as infinite_block_results.

Frequently Asked Questions about manual_tests.infinite_block_tests

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate serial execution of infinite-block tests with sub-agents?

Automating serial execution of infinite-block tests involves delegating work to sub-agents running in strict order with per-test resets. This prevents cross-test interference and ensures deterministic blocking behavior is observable by recording queue status after each scenario.

What is the best way to verify non-promise and promise blocking behavior in a QA workflow?

Verifying non-promise and promise blocking behavior requires running test cases that observe both bypass and blocking outcomes. By checking queue status entries and hook activity after each test, you can confirm correct firing and timing to validate the behavior.

How do I prevent cross-test interference when running multiple infinite-block scenarios?

Preventing cross-test interference when running infinite-block scenarios requires executing tests in strict serial order. Performing a mandatory reset after each test and checking the rules queue ensures that previous test states do not affect subsequent blocking behavior.

Does the Haiku sub-agent model support infinite-block testing with strict turn limits?

The Haiku sub-agent model supports infinite-block testing by enforcing a controlled environment with a strict limit of 5 turns. This configuration ensures deterministic sub-agent execution while observing blocking behavior and recording the results in a queue.

How do I consolidate infinite-block test results into a single artifact?

Consolidating infinite-block test results into a single artifact requires running all test scenarios and capturing hook activity alongside queue status. After executing the tests in serial order with resets, you return the recorded outcomes as an infinite_block_results artifact.

What are the limitations of using sub-agents for infinite-block testing?

Limitations of using sub-agents for infinite-block testing include a strict max_turns limit of 5 and forced serial execution. These constraints ensure controlled testing but may restrict complex, multi-turn interactions or parallel test case processing.