Write a Bash script that watches a directory and prints a summary whenever a new file appears. The summary should include: filename, file size in human-readable form, file type (from the `file` command), and a SHA-256 hash. Handle the case where the directory doesn't exist yet.

Judge: A bash script that waits for the directory to exist, watches via inotifywait, and prints filename, human-readable size, file type, and SHA-256 hash, meeting all hard constraints. Quoting is careful (-- and quoted vars) and it handles vanished files and special chars; it uses 'set -u' rather than full 'set -euo pipefail' and relies on Linux-only tools (inotifywait, stat -c, numfmt), which is reasonable but limits portability.

Judge: Syntax-checked clean, and the missing-directory handling was verified live (it waits, detects the directory appearing, and starts watching). All four summary fields are produced (du -h size, file -b type, sha256sum), with an inotify mode plus a polling fallback that pre-seeds existing files and uses null-delimited find for special filenames. Dings: du reports block-rounded disk usage rather than exact file size, the associative array silently requires bash 4+ (it breaks on macOS's stock bash 3.2, a portability gap the otherwise-thorough macOS note misses), and it uses set -u but not the full set -euo pipefail.

Judge: Complete dependency-free polling watcher: waits for the directory, tracks seen files in an associative array, uses find -print0 for special-character safety, and prints all four required fields. Drawbacks: GNU-only stat -c/numfmt (breaks on macOS), unbounded 'seen' growth, a fixed 1s settle delay as the only partial-write guard, and recreated same-name files are never re-reported. Clean set -euo pipefail style and clear notes.

Judge: A solid bash script: waits for the directory to exist, uses inotifywait on close_write/moved_to (smartly avoiding partially-written files), and prints filename, human-readable size, file type, and SHA-256 — all hard constraints met. Robustness is reasonable (tool checks, IFS-safe reads handling spaces, vanished-file guard) but it's Linux-only, dies silently if the directory is later deleted, and du reports disk usage rather than apparent file size. Quoting is correct throughout, though there's no set -euo pipefail; the accompanying explanation is clear and well-organized.

Judge: A solid bash script that handles the missing-directory case via inotifywait on the parent. Uses set -euo pipefail, proper quoting, and checks for required commands. Displays all four required summary fields. Main limitation: inotifywait is Linux-only (not available on macOS), and the script uses Linux-specific stat flags (-c '%s'). Race conditions with rapid file creation are partially handled but not robustly addressed.

Judge: Complete, well-structured bash script using inotifywait. Handles directory creation with mkdir -p, prints filename/size/type/SHA-256. Good error handling, proper quoting, command existence checks. However, relies on Linux-only inotifywait (not portable), verbose explanation padding, and lacks set -euo pipefail. The response itself is truncated in the explanation section but the script is complete.

Judge: Handles directory creation, includes argument validation, has a human-readable size function with fallback. Response truncated but visible portions show reasonable bash scripting with proper quoting. Missing set -euo pipefail at the top. The cross-platform size detection (numfmt vs ls fallback) is a nice touch but the stat syntax shown is Linux-specific (not macOS compatible).

Judge: Truncated but shows strong bash fundamentals: set -euo pipefail, proper quoting, handles both macOS and Linux stat, human_readable_size function, checks for directory existence. The polling approach with tracking file is reasonable. Handles missing files. Cut off before SHA-256 hash section, but the visible code is production-quality bash.

Judge: Reasonable bash script structure with proper quoting and functions. Handles the directory-not-existing case with a polling loop. However, uses inotifywait (Linux-only) without mentioning portability, uses sha256sum instead of shasum (platform-dependent), and the response is truncated before the main watch loop. The dependency check function is a good practice. Missing set -euo pipefail.

Judge: Meets hard constraints: bash script, handles missing directory (mkdir -p), displays all four required fields. Uses set -euo pipefail which is good practice. However, relies on inotifywait (Linux-specific, not available on macOS), uses Linux-specific stat flags, and moves files to a _processed directory which is a questionable design choice not requested. The globbing approach could miss files that appear between iterations.

Judge: Functional script that handles directory creation and uses inotifywait for file watching. However, uses Linux-only tools (inotifywait, GNU stat, numfmt) without noting portability issues, lacks set -euo pipefail, and has quoting issues in the while-read loop that would break on filenames with spaces.

Judge: The script is truncated mid-output, cutting off during the human-readable size calculation. What's visible shows good practices: command existence checks, directory wait loop, inotifywait usage, and quoting. However, the response is incomplete -- we can't verify it displays all required fields (filename, size, file type, SHA-256). Uses Linux-specific tools (inotifywait, numfmt) without noting macOS incompatibility. The truncation significantly limits the grade.

Judge: Script has multiple issues: uses 'convert-size --si' which is not a standard utility, uses Linux-specific 'stat -c%s' (won't work on macOS), uses inotifywait without checking if directory exists first (the prompt specifically requires handling missing directory). The find command after inotifywait rescans all files rather than just new ones. No set -euo pipefail, no proper error handling.

Judge: The model produced no output at all. Every hard constraint is violated and there is nothing to evaluate, so all dimensions score zero.