claude-dev-env 2.12.0 → 2.13.0

package/hooks/lifecycle/pr_converge_bugteam_skill_tracker.py

@@ -1,198 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: record formal bugteam Skill invocations into pr-converge state.
-
-Companion to ``pr_converge_bugteam_enforcer``. On every
-``Skill({skill: "bugteam"})`` invocation, this hook stamps
-``$CLAUDE_JOB_DIR/pr-converge-state.json`` with
-``bugteam_skill_invoked_at_head = current_head`` and
-``bugteam_skill_invoked_at_tick = tick_count`` so the enforcer can confirm
-the formal Skill fired this tick at the current HEAD before allowing any
-follow-on clean-coder audit-shaped Agent spawn.
-
-``qbug`` invocations are deliberately ignored — qbug is not an accepted
-substitute for the formal bugteam Skill at Step 5.
-
-The hook never blocks: it returns exit 0 in every branch so the Skill call
-proceeds unchanged.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-import tempfile
-from pathlib import Path
-from typing import TextIO
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.pr_converge_bugteam_enforcer_constants import (  # noqa: E402
-    BUGTEAM_SKILL_NAME,
-    SKILL_TOOL_NAME,
-    STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_HEAD,
-    STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_TICK,
-    STATE_FIELD_CURRENT_HEAD,
-    STATE_FIELD_TICK_COUNT,
-    STATE_FILE_ATOMIC_WRITE_SUFFIX,
-    STATE_FILE_JSON_INDENT_SPACES,
-)
-from hooks_constants.pr_converge_bugteam_enforcer_state import (  # noqa: E402
-    load_state_dictionary,
-    resolve_state_path,
-)
-
-
-def _atomic_write_state(state_path: Path, state_by_field: dict[str, object]) -> None:
-    """Serialize state to disk atomically via tempfile + rename.
-
-    Args:
-        state_path: Destination ``pr-converge-state.json`` path.
-        state_by_field: Updated state mapping each field name to its value.
-    """
-    parent_directory = state_path.parent
-    parent_directory.mkdir(parents=True, exist_ok=True)
-    encoded_text = json.dumps(state_by_field, indent=STATE_FILE_JSON_INDENT_SPACES, sort_keys=True)
-    with tempfile.NamedTemporaryFile(
-        mode="w",
-        encoding="utf-8",
-        dir=str(parent_directory),
-        delete=False,
-        suffix=STATE_FILE_ATOMIC_WRITE_SUFFIX,
-    ) as temporary_handle:
-        temporary_handle.write(encoded_text)
-        temporary_path = Path(temporary_handle.name)
-    try:
-        os.replace(str(temporary_path), str(state_path))
-    except OSError:
-        Path(temporary_path).unlink(missing_ok=True)
-        raise
-
-
-def _emit_missing_state_warning(output_stream: TextIO) -> None:
-    """Write the missing-state warning to the provided stream.
-
-    Args:
-        output_stream: Writable text stream — production code passes
-            ``sys.stderr``; tests pass a ``StringIO`` to capture the message.
-    """
-    output_stream.write(
-        "pr_converge_bugteam_skill_tracker: state file lacks current_head or "
-        "tick_count; bugteam invocation NOT recorded\n"
-    )
-    output_stream.flush()
-
-
-def _record_bugteam_skill_invocation(
-    state_by_field: dict[str, object],
-) -> dict[str, object] | None:
-    """Return a copy of state with bugteam-Skill invocation fields stamped, or None on no-op.
-
-    The two stamp fields are owned exclusively by this tracker. Concurrent
-    writes from the orchestrator never touch them, so the read-modify-write
-    window cannot lose an orchestrator update on these specific keys.
-
-    When ``current_head`` (str) or ``tick_count`` (int) is missing or wrong-typed,
-    the function emits a stderr warning via ``_emit_missing_state_warning`` and
-    returns ``None`` so the caller skips the disk write entirely. Skipping the
-    no-op write narrows the read-modify-write window against the orchestrator —
-    concurrent updates to non-stamp fields (``phase``, ``tick_count``, etc.)
-    cannot be silently lost by a tracker rewrite that changes nothing.
-
-    Args:
-        state_by_field: Existing pr-converge state mapping each field name to
-            its value.
-
-    Returns:
-        New dictionary identical to ``state_by_field`` plus
-        ``bugteam_skill_invoked_at_head`` set to ``current_head`` and
-        ``bugteam_skill_invoked_at_tick`` set to ``tick_count`` when both
-        source fields are present and well-typed; ``None`` when either source
-        field is missing or wrong-typed, signaling the caller to skip the
-        atomic write.
-    """
-    current_head = state_by_field.get(STATE_FIELD_CURRENT_HEAD)
-    current_tick = state_by_field.get(STATE_FIELD_TICK_COUNT)
-    if not isinstance(current_head, str) or not isinstance(current_tick, int):
-        _emit_missing_state_warning(sys.stderr)
-        return None
-    updated_state: dict[str, object] = dict(state_by_field)
-    updated_state[STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_HEAD] = current_head
-    updated_state[STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_TICK] = current_tick
-    return updated_state
-
-
-def _is_formal_bugteam_skill_invocation(payload_by_field: dict[str, object]) -> bool:
-    """Return True when this hook invocation matches the formal bugteam Skill.
-
-    Args:
-        payload_by_field: The full PreToolUse hook payload (already JSON-parsed),
-            keyed by top-level field name.
-
-    Returns:
-        True when ``tool_name == "Skill"`` and ``tool_input["skill"]
-        == "bugteam"``. Returns False for qbug and every other skill.
-    """
-    if payload_by_field.get("tool_name", "") != SKILL_TOOL_NAME:
-        return False
-    tool_input = payload_by_field.get("tool_input", {})
-    if not isinstance(tool_input, dict):
-        return False
-    return tool_input.get("skill", "") == BUGTEAM_SKILL_NAME
-
-
-def _emit_state_write_error(state_write_error: OSError, output_stream: TextIO) -> None:
-    """Write the state-write failure message to the provided stream.
-
-    Args:
-        state_write_error: The OSError raised by ``_atomic_write_state``.
-        output_stream: Writable text stream — production code passes
-            ``sys.stderr``; tests pass a ``StringIO`` to capture the message.
-    """
-    output_stream.write(
-        f"pr_converge_bugteam_skill_tracker: state write failed; "
-        f"stamp not recorded: {state_write_error}\n"
-    )
-    output_stream.flush()
-
-
-def main() -> None:
-    """Tracker entry point for the PreToolUse:Skill hook.
-
-    Reads the PreToolUse payload from stdin, records a formal
-    ``Skill({skill: "bugteam"})`` invocation in the pr-converge state file,
-    and always returns 0 — including on a state-write failure, since a
-    non-zero PreToolUse exit would block the very Skill invocation this
-    hook exists to record. State-write failures are surfaced via
-    ``_emit_state_write_error`` to stderr so the operator still sees the
-    protocol-corruption signal.
-    """
-    try:
-        hook_payload = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        return
-    if not isinstance(hook_payload, dict):
-        return
-    if not _is_formal_bugteam_skill_invocation(hook_payload):
-        return
-    state_path = resolve_state_path()
-    if state_path is None:
-        return
-    parsed_state = load_state_dictionary(state_path)
-    if parsed_state is None:
-        return
-    updated_state = _record_bugteam_skill_invocation(parsed_state)
-    if updated_state is None:
-        return
-    try:
-        _atomic_write_state(state_path, updated_state)
-    except OSError as state_write_error:
-        _emit_state_write_error(state_write_error, sys.stderr)
-        return
-    return
-
-
-if __name__ == "__main__":
-    main()

package/hooks/lifecycle/test_pr_converge_bugteam_skill_tracker.py

@@ -1,283 +0,0 @@
-"""Unit tests for the pr_converge_bugteam_skill_tracker PreToolUse hook.
-
-Covers the bugteam-only update path: only Skill({skill: "bugteam"}) updates
-the invocation fields in $CLAUDE_JOB_DIR/pr-converge-state.json (the file
-named by PR_CONVERGE_STATE_FILENAME). qbug, other skills, and missing-state
-cases all return exit 0 without modifying state.
-"""
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import json
-import pathlib
-import sys
-from typing import Any
-from unittest import mock
-
-import pytest
-
-_HOOK_DIR = pathlib.Path(__file__).parent
-_HOOKS_TREE = _HOOK_DIR.parent
-for each_path in (str(_HOOK_DIR), str(_HOOKS_TREE)):
-    if each_path not in sys.path:
-        sys.path.insert(0, each_path)
-
-hook_spec = importlib.util.spec_from_file_location(
-    "pr_converge_bugteam_skill_tracker",
-    _HOOK_DIR / "pr_converge_bugteam_skill_tracker.py",
-)
-assert hook_spec is not None
-assert hook_spec.loader is not None
-hook_module = importlib.util.module_from_spec(hook_spec)
-hook_spec.loader.exec_module(hook_module)
-
-from hooks_constants.pr_converge_bugteam_enforcer_constants import (
-    CLAUDE_JOB_DIR_ENV_VAR,
-    PR_CONVERGE_STATE_FILENAME,
-)
-
-_HEAD_SHA = "abc123def456abc123def456abc123def456abcd"
-_TICK_COUNT = 4
-
-
-def _write_state(state_directory: pathlib.Path, state: dict[str, Any]) -> pathlib.Path:
-    state_path = state_directory / PR_CONVERGE_STATE_FILENAME
-    state_path.write_text(json.dumps(state), encoding="utf-8")
-    return state_path
-
-
-def _baseline_state() -> dict[str, Any]:
-    return {
-        "phase": "BUGTEAM",
-        "current_head": _HEAD_SHA,
-        "tick_count": _TICK_COUNT,
-        "bugteam_skill_invoked_at_head": None,
-        "bugteam_skill_invoked_at_tick": None,
-    }
-
-
-def _read_state(state_directory: pathlib.Path) -> dict[str, Any]:
-    state_path = state_directory / PR_CONVERGE_STATE_FILENAME
-    return json.loads(state_path.read_text(encoding="utf-8"))
-
-
-def _run_main_with_io(input_text: str) -> None:
-    with mock.patch("sys.stdin", io.StringIO(input_text)):
-        with mock.patch("sys.stdout", new_callable=io.StringIO):
-            try:
-                hook_module.main()
-            except SystemExit:
-                pass
-
-
-def _run_main_capturing_stderr(input_text: str) -> str:
-    with mock.patch("sys.stdin", io.StringIO(input_text)):
-        with mock.patch("sys.stdout", new_callable=io.StringIO):
-            with mock.patch("sys.stderr", new_callable=io.StringIO) as captured_stderr:
-                try:
-                    hook_module.main()
-                except SystemExit:
-                    pass
-                return captured_stderr.getvalue()
-
-
-@pytest.fixture()
-def claude_job_directory(tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch) -> pathlib.Path:
-    monkeypatch.setenv(CLAUDE_JOB_DIR_ENV_VAR, str(tmp_path))
-    return tmp_path
-
-
-def test_should_record_invocation_when_bugteam_skill_fires(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    _write_state(claude_job_directory, _baseline_state())
-    skill_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "bugteam", "args": "https://github.com/o/r/pull/1"},
-    }
-    _run_main_with_io(json.dumps(skill_payload))
-    updated_state = _read_state(claude_job_directory)
-    assert updated_state["bugteam_skill_invoked_at_head"] == _HEAD_SHA
-    assert updated_state["bugteam_skill_invoked_at_tick"] == _TICK_COUNT
-
-
-def test_should_not_record_invocation_when_qbug_skill_fires(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    _write_state(claude_job_directory, _baseline_state())
-    qbug_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "qbug"},
-    }
-    _run_main_with_io(json.dumps(qbug_payload))
-    updated_state = _read_state(claude_job_directory)
-    assert updated_state["bugteam_skill_invoked_at_head"] is None
-    assert updated_state["bugteam_skill_invoked_at_tick"] is None
-
-
-def test_should_ignore_unrelated_skills(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    _write_state(claude_job_directory, _baseline_state())
-    other_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "agent-prompt"},
-    }
-    _run_main_with_io(json.dumps(other_payload))
-    updated_state = _read_state(claude_job_directory)
-    assert updated_state["bugteam_skill_invoked_at_head"] is None
-
-
-def test_should_ignore_non_skill_tools(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    _write_state(claude_job_directory, _baseline_state())
-    agent_payload: dict[str, Any] = {
-        "tool_name": "Agent",
-        "tool_input": {"subagent_type": "clean-coder", "prompt": "fix this"},
-    }
-    _run_main_with_io(json.dumps(agent_payload))
-    updated_state = _read_state(claude_job_directory)
-    assert updated_state["bugteam_skill_invoked_at_head"] is None
-
-
-def test_should_no_op_when_state_file_absent(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    skill_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "bugteam"},
-    }
-    _run_main_with_io(json.dumps(skill_payload))
-    assert not (claude_job_directory / PR_CONVERGE_STATE_FILENAME).exists()
-
-
-def test_should_no_op_when_state_json_is_malformed(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    state_path = claude_job_directory / PR_CONVERGE_STATE_FILENAME
-    state_path.write_text("{not valid json", encoding="utf-8")
-    skill_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "bugteam"},
-    }
-    _run_main_with_io(json.dumps(skill_payload))
-    assert state_path.read_text(encoding="utf-8") == "{not valid json"
-
-
-def test_should_preserve_other_state_fields_on_update(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    baseline_state = _baseline_state()
-    baseline_state["bugbot_clean_at"] = _HEAD_SHA
-    baseline_state["copilot_wait_count"] = 2
-    _write_state(claude_job_directory, baseline_state)
-    skill_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "bugteam"},
-    }
-    _run_main_with_io(json.dumps(skill_payload))
-    updated_state = _read_state(claude_job_directory)
-    assert updated_state["bugbot_clean_at"] == _HEAD_SHA
-    assert updated_state["copilot_wait_count"] == 2
-    assert updated_state["bugteam_skill_invoked_at_head"] == _HEAD_SHA
-
-
-def test_should_no_op_when_claude_job_dir_env_var_absent(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.delenv(CLAUDE_JOB_DIR_ENV_VAR, raising=False)
-    skill_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "bugteam"},
-    }
-    _run_main_with_io(json.dumps(skill_payload))
-
-
-def test_should_no_op_when_payload_is_malformed_json(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    baseline_state = _baseline_state()
-    _write_state(claude_job_directory, baseline_state)
-    _run_main_with_io("not valid json {{{")
-    updated_state = _read_state(claude_job_directory)
-    assert updated_state["bugteam_skill_invoked_at_head"] is None
-
-
-def test_should_leave_state_unchanged_when_current_head_is_missing(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    state_without_head = _baseline_state()
-    del state_without_head["current_head"]
-    _write_state(claude_job_directory, state_without_head)
-    skill_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "bugteam"},
-    }
-    captured_stderr = _run_main_capturing_stderr(json.dumps(skill_payload))
-    updated_state = _read_state(claude_job_directory)
-    assert "current_head" not in updated_state
-    assert updated_state.get("bugteam_skill_invoked_at_head") is None
-    assert updated_state.get("bugteam_skill_invoked_at_tick") is None
-    assert "current_head or tick_count" in captured_stderr
-
-
-def test_should_leave_state_unchanged_when_tick_count_is_missing(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    state_without_tick = _baseline_state()
-    del state_without_tick["tick_count"]
-    _write_state(claude_job_directory, state_without_tick)
-    skill_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "bugteam"},
-    }
-    captured_stderr = _run_main_capturing_stderr(json.dumps(skill_payload))
-    updated_state = _read_state(claude_job_directory)
-    assert "tick_count" not in updated_state
-    assert updated_state.get("bugteam_skill_invoked_at_head") is None
-    assert updated_state.get("bugteam_skill_invoked_at_tick") is None
-    assert "current_head or tick_count" in captured_stderr
-
-
-def test_should_preserve_prior_stamp_when_current_head_becomes_missing(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    prior_head = "feedface0000feedface0000feedface0000feed"
-    prior_tick = 3
-    state_with_prior_stamp = _baseline_state()
-    state_with_prior_stamp["bugteam_skill_invoked_at_head"] = prior_head
-    state_with_prior_stamp["bugteam_skill_invoked_at_tick"] = prior_tick
-    del state_with_prior_stamp["current_head"]
-    _write_state(claude_job_directory, state_with_prior_stamp)
-    skill_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "bugteam"},
-    }
-    _run_main_capturing_stderr(json.dumps(skill_payload))
-    updated_state = _read_state(claude_job_directory)
-    assert updated_state["bugteam_skill_invoked_at_head"] == prior_head
-    assert updated_state["bugteam_skill_invoked_at_tick"] == prior_tick
-
-
-def test_should_skip_atomic_write_when_state_missing_required_fields(
-    claude_job_directory: pathlib.Path,
-) -> None:
-    state_without_head = _baseline_state()
-    del state_without_head["current_head"]
-    _write_state(claude_job_directory, state_without_head)
-    skill_payload: dict[str, Any] = {
-        "tool_name": "Skill",
-        "tool_input": {"skill": "bugteam"},
-    }
-    with mock.patch.object(hook_module, "_atomic_write_state") as patched_atomic_write:
-        with mock.patch("sys.stdin", io.StringIO(json.dumps(skill_payload))):
-            with mock.patch("sys.stdout", new_callable=io.StringIO):
-                with mock.patch("sys.stderr", new_callable=io.StringIO):
-                    try:
-                        hook_module.main()
-                    except SystemExit:
-                        pass
-        assert patched_atomic_write.call_count == 0

package/rules/proof-of-work-pr-comments.md

@@ -1,22 +0,0 @@
-# Proof-of-Work PR Comments
-
-**When this applies:** Every pull request. One comment on the PR carries the proof of the work — posted after `gh pr create` or after a material new commit, and always before the PR leaves draft.
-
-## The standard
-
-A proof comment has five parts:
-
-1. **The exact commands run on real data.** A fenced code block showing the command(s) that produced the artifact — not test output alone.
-2. **Measured outcomes.** Numbers read from the produced artifact — counts, dimensions, hashes, byte sizes, rankings — as a table or a bullet list of facts.
-3. **Plan linkage.** One sentence naming the parent issue or phase the PR advances, with the issue reference (for example: "Advances phase 2 of issue #12").
-4. **Visual evidence for values a human cannot read at a glance.** When the change is visual (the diff touches images, HTML, CSS, or hex color values), embed an image: hex colors as inline swatch images (`![](https://placehold.co/20x20/RRGGBB/RRGGBB.png)`), coordinates as marked-up screenshots, size changes as before/after pairs. A wall of raw values fails the standard even when every value is correct.
-5. **Honest gaps.** State plainly what the offline proof cannot show, and what covers that gap.
-
-## Enforcement
-
-The `pr_description_enforcer` hook enforces the standard at two points:
-
-- **On `gh pr comment`:** a comment body whose heading names proof or verification is audited for the five parts. The audit looks for a fenced code block with content, a table row or bullet line carrying a number, a line pairing an issue reference (`#123`) with a linkage word (issue, phase, plan, parent, advances, milestone, part of), an image embed when the PR diff is visual, and a gap phrase (gap, limitation, cannot, does not show, not shown, unverified, not covered). The block message names each missing part.
-- **On `gh pr ready`:** the hook reads the PR's comments and blocks readying while no comment passes the audit. `gh pr ready --undo` returns a PR to draft and is never blocked.
-
-A `gh` failure (network, auth, missing executable) never blocks — the gate fails open on tooling problems, and the comment audit skips bodies it cannot read.

package/rules/verified-commit-gate-skip.md

@@ -1,4 +0,0 @@
-# Optional Verifier Review
-
-Code-verifier review is an optional workflow selected by the task owner.
-Commit and push operations use the checks selected for the task.

package/scripts/Show-Asset.ps1

@@ -1,106 +0,0 @@
-<#
-.SYNOPSIS
-Opens files on screen, sizing each image window to the image's own dimensions.
-
-.DESCRIPTION
-For every path given, an image opens in a window whose client area matches the
-image's pixel size, scaled down to fit the primary screen's working area when the
-image is larger than the screen. A small image gets a usable minimum window with
-the picture centered at native size. Non-image files open in their registered
-default application, and any file that cannot be loaded as an image falls back to
-that default application too. Escape or the close button dismisses a window; the
-process exits once every window is closed.
-
-.PARAMETER Paths
-One or more file paths to open.
-#>
-param(
-    [Parameter(ValueFromRemainingArguments = $true)]
-    [string[]]$Paths
-)
-
-Add-Type -AssemblyName System.Windows.Forms
-Add-Type -AssemblyName System.Drawing
-
-try {
-    [System.Windows.Forms.Application]::SetHighDpiMode([System.Windows.Forms.HighDpiMode]::PerMonitorV2) | Out-Null
-}
-catch {
-    $null = $_
-}
-[System.Windows.Forms.Application]::EnableVisualStyles()
-
-$imageExtensions = @('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.tif', '.tiff', '.ico')
-$screenMargin = 80
-$minimumClientWidth = 220
-$minimumClientHeight = 160
-$openWindowCount = 0
-
-foreach ($path in $Paths) {
-    if (-not (Test-Path -LiteralPath $path)) { continue }
-    $fullPath = (Resolve-Path -LiteralPath $path).Path
-    $extension = [System.IO.Path]::GetExtension($fullPath).ToLowerInvariant()
-
-    if ($imageExtensions -notcontains $extension) {
-        Invoke-Item -LiteralPath $fullPath
-        continue
-    }
-
-    try {
-        $imageBytes = [System.IO.File]::ReadAllBytes($fullPath)
-        $imageStream = New-Object System.IO.MemoryStream(, $imageBytes)
-        $loadedImage = [System.Drawing.Image]::FromStream($imageStream)
-        $image = New-Object System.Drawing.Bitmap($loadedImage)
-        $loadedImage.Dispose()
-        $imageStream.Dispose()
-    }
-    catch {
-        Invoke-Item -LiteralPath $fullPath
-        continue
-    }
-
-    $workingArea = [System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea
-    $maximumWidth = $workingArea.Width - $screenMargin
-    $maximumHeight = $workingArea.Height - $screenMargin
-    $scale = [Math]::Min(1.0, [Math]::Min($maximumWidth / $image.Width, $maximumHeight / $image.Height))
-
-    $pictureBox = New-Object System.Windows.Forms.PictureBox
-    $pictureBox.Dock = [System.Windows.Forms.DockStyle]::Fill
-    $pictureBox.Image = $image
-
-    if ($scale -lt 1.0) {
-        $pictureBox.SizeMode = [System.Windows.Forms.PictureBoxSizeMode]::Zoom
-        $clientWidth = [int][Math]::Round($image.Width * $scale)
-        $clientHeight = [int][Math]::Round($image.Height * $scale)
-    }
-    else {
-        $pictureBox.SizeMode = [System.Windows.Forms.PictureBoxSizeMode]::CenterImage
-        $clientWidth = [Math]::Max($minimumClientWidth, $image.Width)
-        $clientHeight = [Math]::Max($minimumClientHeight, $image.Height)
-    }
-
-    $form = New-Object System.Windows.Forms.Form
-    $form.Text = [System.IO.Path]::GetFileName($fullPath)
-    $form.AutoScaleMode = [System.Windows.Forms.AutoScaleMode]::None
-    $form.StartPosition = [System.Windows.Forms.FormStartPosition]::CenterScreen
-    $form.ClientSize = New-Object System.Drawing.Size($clientWidth, $clientHeight)
-    $form.KeyPreview = $true
-    $form.BackColor = [System.Drawing.Color]::FromArgb(24, 24, 24)
-    $form.Controls.Add($pictureBox)
-
-    $form.Add_KeyDown({
-            param($sender, $eventArguments)
-            if ($eventArguments.KeyCode -eq [System.Windows.Forms.Keys]::Escape) { $sender.Close() }
-        })
-    $form.Add_FormClosed({
-            $script:openWindowCount--
-            if ($script:openWindowCount -le 0) { [System.Windows.Forms.Application]::Exit() }
-        })
-
-    $openWindowCount++
-    $form.Show()
-}
-
-if ($openWindowCount -gt 0) {
-    [System.Windows.Forms.Application]::Run()
-}