Skip to content

amazon-science/ammo / ai_cli_session/.codex/skills/ammo

Profile and optimize GPU kernels for vLLM inference on NVIDIA GPUs. Use when targeting a specific model, hardware, dtype, parallelism, and workload to improve latency.

FileKindSize
RUNTIME.mdmarkdown4.9 KB
SKILL.mdskill md18.5 KB
agents/ammo-auditor.mdmarkdown9.1 KB
agents/ammo-champion.mdmarkdown9.6 KB
agents/ammo-delegate.mdmarkdown3.2 KB
agents/ammo-implementer.mdmarkdown13.8 KB
agents/ammo-investigator.mdmarkdown4.0 KB
agents/ammo-report.mdmarkdown2.9 KB
agents/ammo-researcher.mdmarkdown10.3 KB
agents/ammo-resolver.mdmarkdown4.4 KB
agents/ammo-transcript-monitor.mdmarkdown7.8 KB
agents/openai.yamlexecutablescript313 B
data/ATTRIBUTION.mdmarkdown1.4 KB
data/gsm8k_full.jsonexecutablescript735.5 KB
data/gsm8k_subset.jsonexecutablescript116.8 KB
eval/EVAL-SKILL.mdexecutablescript21.8 KB
eval/agents/transcript_grader.mdexecutablescript18.0 KB
eval/causal/__init__.pyexecutablescript137 B
eval/causal/agents/causal_analyzer.mdexecutablescript10.5 KB
eval/causal/build_dag.pyexecutablescript21.6 KB
eval/causal/diff_versions.pyexecutablescript38.5 KB
eval/causal/extract_events.pyexecutablescript36.3 KB
eval/causal/generate_postmortem.pyexecutablescript17.0 KB
eval/causal/score_nodes.pyexecutablescript21.5 KB
eval/causal/templates/narrative_template.mdexecutablescript472 B
eval/causal/templates/viz_template.htmlexecutablescript9.5 KB
eval/causal/tests/__init__.pyexecutablescript151 B
eval/causal/tests/conftest.pyexecutablescript448 B
eval/causal/tests/fixtures/sample_session.jsonlexecutablescript10.4 KB
eval/causal/tests/fixtures/sample_session_data.jsonexecutablescript3.4 KB
eval/causal/tests/fixtures/sample_snapshot.jsonexecutablescript2.5 KB
eval/causal/tests/test_build_dag.pyexecutablescript2.7 KB
eval/causal/tests/test_diff_versions.pyexecutablescript13.5 KB
eval/causal/tests/test_extract_events.pyexecutablescript3.7 KB
eval/causal/tests/test_generate_postmortem.pyexecutablescript3.1 KB
eval/causal/tests/test_score_nodes.pyexecutablescript3.3 KB
eval/scripts/aggregate_versions.pyexecutablescript15.2 KB
eval/scripts/archive_run.pyexecutablescript9.1 KB
eval/scripts/codex_session.pyexecutablescript10.6 KB
eval/scripts/generate_dashboard.pyexecutablescript5.3 KB
eval/scripts/parse_artifacts.pyexecutablescript48.1 KB
eval/scripts/parse_session_logs.pyexecutablescript51.3 KB
eval/scripts/rescore_archived.pyexecutablescript5.5 KB
eval/scripts/score_campaign.pyexecutablescript43.8 KB
eval/scripts/snapshot_changes.pyexecutablescript11.1 KB
eval/scripts/verify_citations.pyexecutablescript8.8 KB
eval/tests/test_dashboard_bugs.pyexecutablescript8.8 KB
eval/tests/test_parse_session_logs.pyexecutablescript3.9 KB
eval/tests/test_parse_session_logs_round_inference.pyexecutablescript11.0 KB
eval/tests/test_score_campaign_diluted.pyexecutablescript9.4 KB
eval/viewer/dashboard_template.htmlexecutablescript15.1 KB
instrumentation/sitecustomize.pyexecutablescript3.6 KB
orchestration/audit-protocol.mdmarkdown9.3 KB
orchestration/debate-protocol.mdmarkdown11.2 KB
orchestration/integration-logic.mdmarkdown10.3 KB
orchestration/parallel-tracks.mdmarkdown8.9 KB
references/artifact-layout.mdexecutablescript22.4 KB
references/audit-invariants.mdmarkdown10.6 KB
references/champion-common-patterns.mdmarkdown3.4 KB
references/crossover-probing.mdexecutablescript4.7 KB
references/cudagraph-safety.mdmarkdown2.7 KB
references/debate-rules.mdmarkdown4.7 KB
references/debate-scoring-rubric.mdexecutablescript16.7 KB
references/e2e-delta-math.mdexecutablescript17.9 KB
references/e2e-latency-guide.mdexecutablescript9.6 KB
references/fusion-feasibility-heuristics.mdmarkdown5.6 KB
references/gpu-pool.mdexecutablescript5.4 KB
references/impl-track-rules.mdexecutablescript13.8 KB
references/nsys-profiling-guide.mdmarkdown9.8 KB
references/optimization-categories.mdexecutablescript11.0 KB
references/shutdown-protocol.mdexecutablescript3.1 KB
references/technology-selection.mdmarkdown5.0 KB
references/torch-compile-contract.mdmarkdown13.8 KB
references/validation-defaults.mdexecutablescript34.2 KB
references/workload-invocation.mdexecutablescript4.9 KB
references/writing-style.mdexecutablescript6.9 KB
scripts/ammo_state.pyexecutablescript142.0 KB
scripts/artifact_layout.jsonconfig16.3 KB
scripts/check_projection_accuracy.pyexecutablescript11.7 KB
scripts/create_evidence_template.pyexecutablescript9.7 KB
scripts/create_worktree_with_build.shexecutablescript10.2 KB
scripts/generate_validation_report.pyexecutablescript35.7 KB
scripts/gpu_reservation.pyexecutablescript27.1 KB
scripts/hook_cmd_classify.pyscript13.3 KB
scripts/mine_trace.pyscript29.4 KB
scripts/monitor_queue_ack.pyexecutablescript6.1 KB
scripts/ncu_sanity.shexecutablescript5.2 KB
scripts/ncu_sanity_driver.pyexecutablescript8.5 KB
scripts/new_target.pyexecutablescript22.0 KB
scripts/preflight_vllm_api.pyexecutablescript12.3 KB
scripts/reconcile_track_state.pyexecutablescript15.8 KB
scripts/remove_worktree_cleanup.shexecutablescript1.1 KB
scripts/resolve_codex_transcript.pyexecutablescript3.6 KB
scripts/run_vllm_bench_latency_sweep.pyexecutablescript249.6 KB
scripts/transcript_filter.pyexecutablescript38.4 KB
scripts/transitions.jsonexecutablescript1.5 KB
scripts/verify_validation_gates.pyexecutablescript88.8 KB
tests/agents/test-champion.mdexecutablescript20.4 KB
tests/agents/test-impl-champion.mdexecutablescript14.3 KB
tests/agents/test-implementer.mdexecutablescript15.8 KB
tests/agents/test-orchestrator.mdexecutablescript33.8 KB
tests/agents/test-researcher.mdexecutablescript21.0 KB
tests/agents/test-transcript-monitor.mdexecutablescript13.4 KB
tests/fixtures/diluted_pass/legacy_no_phase.golden.mdmarkdown1.1 KB
tests/fixtures/diluted_pass/legacy_no_phase.golden.summary.jsonconfig582 B
tests/fixtures/diluted_pass/legacy_no_phase.jsonconfig400 B
tests/fixtures/diluted_pass/legacy_scalar_phase.golden.mdmarkdown2.0 KB
tests/fixtures/diluted_pass/legacy_scalar_phase.golden.summary.jsonconfig1.0 KB
tests/fixtures/diluted_pass/legacy_scalar_phase.jsonconfig626 B
tests/fixtures/mining/real_campaign_bottleneck_analysis.mdmarkdown20.7 KB
tests/run_all.shexecutablescript1.6 KB
tests/scripts/test_transcript_filter.pyexecutablescript41.1 KB
tests/test_agent_runtime_contracts.pyexecutablescript1.8 KB
tests/test_ammo_state.pyexecutablescript71.7 KB
tests/test_artifact_layout_manifest.pyscript11.6 KB
tests/test_audit_started.pyscript18.2 KB
tests/test_correctness_comparator.pyscript12.6 KB
tests/test_diluted_pass.pyscript24.4 KB
tests/test_drift_compat.pyscript5.1 KB
tests/test_evidence_freshness.pyexecutablescript5.6 KB
tests/test_fail_closed.pyexecutablescript14.7 KB
tests/test_gpu_reservation.pyexecutablescript24.8 KB
tests/test_gpu_reservation_session_id.pyexecutablescript11.2 KB
tests/test_guidance_semantic_contract.pyscript24.9 KB
tests/test_hook_cmd_classify_parity.pyscript11.7 KB
tests/test_hook_semantics.pyexecutablescript95.3 KB
tests/test_mine_trace.pyscript24.2 KB
tests/test_mining_invalidated_schema.pyexecutablescript9.4 KB
tests/test_new_target_dp_ep.pyexecutablescript7.4 KB
tests/test_new_target_v2_scaffold.pyexecutablescript13.1 KB
tests/test_parse_artifacts.pyexecutablescript3.0 KB
tests/test_policy_convergence.pyscript797 B
tests/test_preflight_vllm_api.pyscript13.3 KB
tests/test_projection_accuracy_v2.pyexecutablescript4.1 KB
tests/test_reconcile_track_state.pyexecutablescript18.2 KB
tests/test_resolve_codex_transcript.pyexecutablescript3.1 KB
tests/test_state_schema_semantics.pyexecutablescript7.6 KB
tests/test_status_set_sync.pyexecutablescript9.1 KB
tests/test_sweep_baseline_from_arm.pyscript11.0 KB
tests/test_sweep_decode_capture.pyexecutablescript31.8 KB
tests/test_sweep_dp.pyexecutablescript45.4 KB
tests/test_sweep_fresh_cache.pyscript5.5 KB
tests/test_sweep_profiler_guard.pyscript22.6 KB
tests/test_sweep_real_prompts.pyscript20.1 KB
tests/test_sweep_refactor.pyexecutablescript37.6 KB
tests/test_sweep_round_slot.pyexecutablescript7.4 KB
tests/test_validation_report_phase_triage.pyexecutablescript10.0 KB
tests/test_validation_report_v2.pyexecutablescript6.2 KB
tests/test_verify_validation_gates.pyexecutablescript52.9 KB
tests/test_workload_matrix.pyexecutablescript19.3 KB

tests/test_gpu_reservation.py

View on GitHub
#!/usr/bin/env python3
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: CC-BY-NC-4.0
"""Tests for gpu_reservation.py — the foundation GPU reservation module.

Run with:
    python -m pytest .codex/skills/ammo/tests/test_gpu_reservation.py -v
"""

from __future__ import annotations

import fcntl
import json
import multiprocessing
import os
import subprocess
import sys
import tempfile
import time
from datetime import datetime, timezone
from pathlib import Path
from unittest import mock

import pytest

# Ensure the scripts directory is importable.
_SCRIPTS_DIR = Path(__file__).resolve().parent.parent / "scripts"
if str(_SCRIPTS_DIR) not in sys.path:
    sys.path.insert(0, str(_SCRIPTS_DIR))

import gpu_reservation
from gpu_reservation import (
    LockTimeoutError,
    ReservationError,
    check_and_reclaim_expired,
    force_clear,
    read_state,
    release_by_session,
    reserve,
    write_reservation,
)


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------

def _make_temp_dir(tmp_path: Path) -> Path:
    """Return a subdirectory inside tmp_path that does NOT yet exist (so
    _init_state can create it)."""
    d = tmp_path / "ammo_gpu_res"
    return d


# ---------------------------------------------------------------------------
# TestInitState
# ---------------------------------------------------------------------------

class TestInitState:
    def test_creates_state_with_gpu_count(self, tmp_path):
        """_init_state with 4 discovered GPUs creates state with 4 null entries."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            state = read_state()

        assert state["gpu_count"] == 4
        assert len(state["gpus"]) == 4
        for v in state["gpus"].values():
            assert v is None

    def test_reads_existing_state(self, tmp_path):
        """read_state returns an already-written state without re-initialising."""
        state_dir = _make_temp_dir(tmp_path)
        state_dir.mkdir(parents=True, exist_ok=True)

        existing = {
            "gpus": {"0": None, "1": None},
            "gpu_count": 2,
            "audit": [],
        }
        state_file = state_dir / "state.json"
        state_file.write_text(json.dumps(existing))

        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(99))):
            # _discover_session_gpus should NOT be called because state already exists
            state = read_state()

        assert state["gpu_count"] == 2
        assert len(state["gpus"]) == 2


# ---------------------------------------------------------------------------
# TestAcquireFlock
# ---------------------------------------------------------------------------

class TestAcquireFlock:
    def test_acquires_lock_on_first_try(self, tmp_path):
        """Basic lock/unlock cycle succeeds without errors."""
        state_dir = _make_temp_dir(tmp_path)
        state_dir.mkdir(parents=True, exist_ok=True)
        lock_file = state_dir / "state.lock"

        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir):
            fh = gpu_reservation._acquire_flock()
            assert fh is not None
            gpu_reservation._release_flock(fh)

    def test_raises_after_5_retries(self, tmp_path):
        """LockTimeoutError raised when lock cannot be acquired after 5 attempts."""
        state_dir = _make_temp_dir(tmp_path)
        state_dir.mkdir(parents=True, exist_ok=True)
        lock_file = state_dir / "state.lock"

        # Hold the lock in this process
        holder = open(lock_file, "w")
        fcntl.flock(holder, fcntl.LOCK_EX | fcntl.LOCK_NB)

        try:
            with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
                 mock.patch.object(gpu_reservation, "BACKOFF_DELAYS", [0.001] * 4):
                with pytest.raises(LockTimeoutError):
                    gpu_reservation._acquire_flock()
        finally:
            fcntl.flock(holder, fcntl.LOCK_UN)
            holder.close()


# ---------------------------------------------------------------------------
# TestWriteReservation
# ---------------------------------------------------------------------------

class TestWriteReservation:
    def test_reserves_free_gpus(self, tmp_path):
        """Reserving free GPUs writes entries into state."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            write_reservation(
                gpu_ids=[0, 1],
                session_id="sess001",
                command_snippet="python bench.py",
                lease_hours=2.0,
            )
            state = read_state()

        assert state["gpus"]["0"] is not None
        assert state["gpus"]["0"]["session_id"] == "sess001"
        assert state["gpus"]["1"] is not None
        assert state["gpus"]["2"] is None
        assert state["gpus"]["3"] is None

    def test_rejects_unknown_gpu_ids(self, tmp_path):
        """Reserving a GPU ID that doesn't exist in state raises ReservationError."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            with pytest.raises(ReservationError, match="not found in state"):
                write_reservation(
                    gpu_ids=[7],
                    session_id="sess_x",
                    command_snippet="python phantom.py",
                    lease_hours=2.0,
                )

    def test_truncates_command_snippet(self, tmp_path):
        """command_snippet is truncated to 80 characters in the stored entry."""
        state_dir = _make_temp_dir(tmp_path)
        long_snippet = "x" * 200
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(1))):
            write_reservation(
                gpu_ids=[0],
                session_id="sess_t",
                command_snippet=long_snippet,
                lease_hours=2.0,
            )
            state = read_state()

        assert len(state["gpus"]["0"]["command_snippet"]) == 80

    def test_blocks_on_held_gpu(self, tmp_path):
        """Trying to reserve an already-held GPU raises ReservationError."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(2))):
            # First reservation succeeds
            write_reservation(
                gpu_ids=[0],
                session_id="sess_a",
                command_snippet="python a.py",
                lease_hours=2.0,
            )
            # Second attempt on same GPU must fail
            with pytest.raises(ReservationError):
                write_reservation(
                    gpu_ids=[0],
                    session_id="sess_b",
                    command_snippet="python b.py",
                    lease_hours=2.0,
                )


# ---------------------------------------------------------------------------
# TestLeaseExpiry
# ---------------------------------------------------------------------------

class TestLeaseExpiry:
    def test_reclaims_expired_leases(self, tmp_path):
        """check_and_reclaim_expired removes entries with lease_hours=0 (already expired)."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(2))):
            # lease_hours=0 means it expires immediately (at the time of writing)
            write_reservation(
                gpu_ids=[0],
                session_id="sess_d",
                command_snippet="python d.py",
                lease_hours=0.0,
            )
            # Small sleep to ensure expiry has passed
            time.sleep(0.01)
            reclaimed = check_and_reclaim_expired()
            state = read_state()

        assert 0 in reclaimed
        assert state["gpus"]["0"] is None


# ---------------------------------------------------------------------------
# TestForceClear
# ---------------------------------------------------------------------------

class TestForceClear:
    def test_clears_by_session_id(self, tmp_path):
        """force_clear(session_id='s1') removes only entries owned by s1."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(2))):
            write_reservation(
                gpu_ids=[0],
                session_id="s1",
                command_snippet="python e.py",
                lease_hours=2.0,
            )
            write_reservation(
                gpu_ids=[1],
                session_id="s2",
                command_snippet="python f.py",
                lease_hours=2.0,
            )
            force_clear(session_id="s1")
            state = read_state()

        assert state["gpus"]["0"] is None, "GPU 0 (owned by s1) should be cleared"
        assert state["gpus"]["1"] is not None, "GPU 1 (owned by s2) should remain"

    def test_requires_session_or_flag(self, tmp_path):
        """force_clear() with no args raises ValueError."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(1))):
            with pytest.raises(ValueError):
                force_clear()


# ---------------------------------------------------------------------------
# TestReserve
# ---------------------------------------------------------------------------

class TestReserve:
    def test_basic_allocation(self, tmp_path):
        """reserve(1) on a 4-GPU system returns [0] and marks GPU 0 reserved."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            result = reserve(num_gpus=1, session_id="s1")
            state = read_state()

        assert result == [0]
        assert state["gpus"]["0"] is not None
        assert state["gpus"]["0"]["session_id"] == "s1"
        assert state["gpus"]["1"] is None

    def test_contiguous_allocation(self, tmp_path):
        """reserve(2) on a 4-GPU system returns [0, 1] (contiguous block)."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            result = reserve(num_gpus=2, session_id="s1")

        assert result == [0, 1]

    def test_contiguous_skips_held(self, tmp_path):
        """GPU 0 held, reserve(2) returns [1, 2] (next contiguous block)."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            # Hold GPU 0
            write_reservation(gpu_ids=[0], session_id="other")
            # Reserve 2 contiguous GPUs
            result = reserve(num_gpus=2, session_id="s1")

        assert result == [1, 2]

    def test_contiguous_fails_fragmented(self, tmp_path):
        """GPUs 0,2 held on 4-GPU system, reserve(2) fails (only [1] and [3] free)."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            # Hold GPUs 0 and 2 with different sessions
            write_reservation(gpu_ids=[0], session_id="other_a")
            write_reservation(gpu_ids=[2], session_id="other_b")
            # Try to reserve 2 contiguous — should fail
            with pytest.raises(ReservationError, match="No contiguous block"):
                reserve(num_gpus=2, session_id="s1")

    def test_auto_release_on_retry(self, tmp_path):
        """Session 's1' holds GPUs 0,1. Calling reserve(2, 's1') releases old first."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            # First reservation
            result1 = reserve(num_gpus=2, session_id="s1")
            assert result1 == [0, 1]
            # Retry — should auto-release [0,1] then re-allocate
            result2 = reserve(num_gpus=2, session_id="s1")
            assert result2 == [0, 1]
            state = read_state()
            assert state["gpus"]["0"]["session_id"] == "s1"
            assert state["gpus"]["1"]["session_id"] == "s1"

    def test_pool_exhausted(self, tmp_path):
        """All 4 GPUs held by different sessions, reserve(1) fails."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            # Fill all GPUs with different sessions
            for i in range(4):
                write_reservation(gpu_ids=[i], session_id=f"other_{i}")
            # Try to reserve 1 — should fail
            with pytest.raises(ReservationError, match="Not enough free GPUs"):
                reserve(num_gpus=1, session_id="s_new")

    def test_contiguous_skips_middle_gap(self, tmp_path):
        """GPU 1 held by different session, GPUs 0,2,3 free, request 2 -> [2,3]."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            # Hold GPU 1
            write_reservation(gpu_ids=[1], session_id="other")
            # Reserve 2 contiguous — GPU 0 alone is not contiguous with
            # anything useful (GPU 1 is held), so [2,3] is the first pair.
            result = reserve(num_gpus=2, session_id="s1")

        assert result == [2, 3]

    def test_non_contiguous_session_pool_uses_physical_ids(self, tmp_path):
        """Session pools may expose non-contiguous physical GPU IDs via CVD."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=[4, 6, 7]):
            result = reserve(num_gpus=2, session_id="s1")
            state = read_state()

        assert result == [6, 7]
        assert sorted(state["gpus"].keys()) == ["4", "6", "7"]
        assert state["gpus"]["4"] is None
        assert state["gpus"]["6"]["session_id"] == "s1"
        assert state["gpus"]["7"]["session_id"] == "s1"

    def test_failed_reserve_preserves_existing(self, tmp_path):
        """Failed reserve must NOT destroy the session's existing reservations."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            # s1 holds GPU 0
            reserve(num_gpus=1, session_id="s1")
            # Fill GPUs 1,2,3 with other sessions
            write_reservation(gpu_ids=[1], session_id="other_1")
            write_reservation(gpu_ids=[2], session_id="other_2")
            write_reservation(gpu_ids=[3], session_id="other_3")

            # Try to reserve 2 GPUs for s1 — must fail (after auto-releasing
            # GPU 0, only 1 GPU free, need 2)
            with pytest.raises(ReservationError):
                reserve(num_gpus=2, session_id="s1")

            # GPU 0 must STILL be held by s1 (failed reserve should not
            # have persisted the auto-release)
            state = read_state()
            assert state["gpus"]["0"] is not None
            assert state["gpus"]["0"]["session_id"] == "s1"

    def test_num_gpus_zero_raises(self, tmp_path):
        """reserve(num_gpus=0) raises ValueError."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            with pytest.raises(ValueError, match="num_gpus must be positive"):
                reserve(num_gpus=0, session_id="s1")

    def test_num_gpus_negative_raises(self, tmp_path):
        """reserve(num_gpus=-1) raises ValueError."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            with pytest.raises(ValueError, match="num_gpus must be positive"):
                reserve(num_gpus=-1, session_id="s1")

    def test_reclaims_expired_before_allocating(self, tmp_path):
        """GPU 0 has expired lease, reserve(1) reclaims it and returns [0]."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(1))):
            # Create an immediately-expiring reservation
            write_reservation(
                gpu_ids=[0],
                session_id="old_session",
                lease_hours=0.0,
            )
            time.sleep(0.01)
            # Reserve should reclaim the expired lease and allocate GPU 0
            result = reserve(num_gpus=1, session_id="new_session")

        assert result == [0]


# ---------------------------------------------------------------------------
# TestReleaseBySession
# ---------------------------------------------------------------------------

class TestReleaseBySession:
    def test_releases_all_session_gpus(self, tmp_path):
        """release_by_session('s1') clears all GPUs held by s1."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            reserve(num_gpus=2, session_id="s1")
            released = release_by_session("s1")
            state = read_state()

        assert sorted(released) == [0, 1]
        assert state["gpus"]["0"] is None
        assert state["gpus"]["1"] is None

    def test_leaves_other_sessions(self, tmp_path):
        """release_by_session('s1') only clears s1, leaves s2 intact."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            write_reservation(gpu_ids=[0], session_id="s1")
            write_reservation(gpu_ids=[1], session_id="s2")
            released = release_by_session("s1")
            state = read_state()

        assert released == [0]
        assert state["gpus"]["0"] is None
        assert state["gpus"]["1"] is not None
        assert state["gpus"]["1"]["session_id"] == "s2"

    def test_unknown_session_returns_empty(self, tmp_path):
        """release_by_session('nonexistent') returns []."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(2))):
            result = release_by_session("nonexistent")

        assert result == []

    def test_include_children_releases_prefixed_subagent_sessions(self, tmp_path):
        """release_by_session(..., include_children=True) clears session child reservations."""
        state_dir = _make_temp_dir(tmp_path)
        with mock.patch.object(gpu_reservation, "STATE_DIR", state_dir), \
             mock.patch("gpu_reservation._discover_session_gpus", return_value=list(range(4))):
            write_reservation(gpu_ids=[0], session_id="sess")
            write_reservation(gpu_ids=[1], session_id="sess:agent-a")
            write_reservation(gpu_ids=[2], session_id="sess-other")
            write_reservation(gpu_ids=[3], session_id="other:sess")

            released = release_by_session("sess", include_children=True)
            state = read_state()

        assert sorted(released) == [0, 1]
        assert state["gpus"]["0"] is None
        assert state["gpus"]["1"] is None
        assert state["gpus"]["2"]["session_id"] == "sess-other"
        assert state["gpus"]["3"]["session_id"] == "other:sess"


# ---------------------------------------------------------------------------
# TestCLI
# ---------------------------------------------------------------------------

class TestCLI:
    def test_reserve_stdout_format(self, tmp_path):
        """CLI 'reserve --num-gpus 2 --session-id test' prints '0,1' to stdout."""
        state_dir = _make_temp_dir(tmp_path)
        script = str(_SCRIPTS_DIR / "gpu_reservation.py")
        env = os.environ.copy()
        env["AMMO_GPU_RES_DIR"] = str(state_dir)

        # Pre-create state so nvidia-smi isn't needed
        state_dir.mkdir(parents=True, exist_ok=True)
        state_file = state_dir / "state.json"
        state_file.write_text(json.dumps({
            "gpus": {"0": None, "1": None, "2": None, "3": None},
            "gpu_count": 4,
            "audit": [],
        }))

        result = subprocess.run(
            [sys.executable, script, "reserve", "--num-gpus", "2",
             "--session-id", "test"],
            capture_output=True, text=True, env=env, timeout=10,
        )
        assert result.returncode == 0
        assert result.stdout.strip() == "0,1"

    def test_reserve_failure_exits_nonzero(self, tmp_path):
        """CLI 'reserve --num-gpus 1' when all GPUs held exits with code 1."""
        state_dir = _make_temp_dir(tmp_path)
        script = str(_SCRIPTS_DIR / "gpu_reservation.py")
        env = os.environ.copy()
        env["AMMO_GPU_RES_DIR"] = str(state_dir)

        # Pre-create state with all GPUs held
        state_dir.mkdir(parents=True, exist_ok=True)
        now_str = datetime.now(tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
        far_future = "2099-01-01T00:00:00Z"
        state_file = state_dir / "state.json"
        state_file.write_text(json.dumps({
            "gpus": {
                str(i): {
                    "session_id": f"blocker_{i}",
                    "reserved_at": now_str,
                    "lease_expires": far_future,
                    "command_snippet": "hold",
                } for i in range(4)
            },
            "gpu_count": 4,
            "audit": [],
        }))

        result = subprocess.run(
            [sys.executable, script, "reserve", "--num-gpus", "1",
             "--session-id", "new"],
            capture_output=True, text=True, env=env, timeout=10,
        )
        assert result.returncode == 1
        assert "Not enough free GPUs" in result.stderr

    def test_release_session_cli_include_children(self, tmp_path):
        """CLI release-session --include-children releases exact and child session ids."""
        state_dir = _make_temp_dir(tmp_path)
        script = str(_SCRIPTS_DIR / "gpu_reservation.py")
        env = os.environ.copy()
        env["AMMO_GPU_RES_DIR"] = str(state_dir)

        state_dir.mkdir(parents=True, exist_ok=True)
        now_str = datetime.now(tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
        far_future = "2099-01-01T00:00:00Z"
        (state_dir / "state.json").write_text(json.dumps({
            "gpus": {
                "0": {"session_id": "sess", "reserved_at": now_str, "lease_expires": far_future, "command_snippet": "hold"},
                "1": {"session_id": "sess:agent", "reserved_at": now_str, "lease_expires": far_future, "command_snippet": "hold"},
                "2": {"session_id": "other", "reserved_at": now_str, "lease_expires": far_future, "command_snippet": "hold"},
            },
            "gpu_count": 3,
            "audit": [],
        }))

        result = subprocess.run(
            [sys.executable, script, "release-session", "--session-id", "sess", "--include-children"],
            capture_output=True, text=True, env=env, timeout=10,
        )
        state = json.loads((state_dir / "state.json").read_text())

        assert result.returncode == 0
        assert state["gpus"]["0"] is None
        assert state["gpus"]["1"] is None
        assert state["gpus"]["2"]["session_id"] == "other"
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall