specsmith 0.2.3.dev51__py3-none-any.whl → 0.2.3.dev55__py3-none-any.whl

specsmith/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import version as _pkg_version
 try:
     __version__: str = _pkg_version("specsmith")
 except PackageNotFoundError:  # running from source without install
-    __version__ = "0.2.2"
+    __version__ = "0.2.3"

specsmith/cli.py

@@ -1501,6 +1501,168 @@ def credits_budget(
     console.print(f"  Enabled:       {budget.enabled}")
 
 
+@credits.group(name="limits")
+def credits_limits() -> None:
+    """Manage persisted per-model RPM/TPM profiles."""
+
+
+@credits_limits.command(name="list")
+@click.option("--project-dir", type=click.Path(exists=True), default=".")
+def credits_limits_list(project_dir: str) -> None:
+    """List configured local model rate-limit profiles."""
+    from specsmith.rate_limits import load_rate_limit_profiles
+
+    root = Path(project_dir).resolve()
+    profiles = sorted(
+        load_rate_limit_profiles(root),
+        key=lambda profile: (profile.provider, profile.model),
+    )
+    if not profiles:
+        console.print("[yellow]No model rate-limit profiles configured.[/yellow]")
+        return
+
+    for profile in profiles:
+        console.print(
+            "  "
+            f"{profile.provider}/{profile.model} "
+            f"RPM={profile.rpm_limit} TPM={profile.tpm_limit} "
+            f"target={profile.utilization_target:.2f} "
+            f"concurrency={profile.concurrency_cap}"
+        )
+
+
+@credits_limits.command(name="set")
+@click.option("--project-dir", type=click.Path(exists=True), default=".")
+@click.option("--provider", required=True, help="Provider key, such as openai or anthropic.")
+@click.option("--model", required=True, help="Model key, such as gpt-5.4.")
+@click.option("--rpm", "rpm_limit", type=int, required=True, help="Requests per minute limit.")
+@click.option("--tpm", "tpm_limit", type=int, required=True, help="Tokens per minute limit.")
+@click.option("--target", "utilization_target", type=float, default=0.7, show_default=True)
+@click.option("--concurrency", "concurrency_cap", type=int, default=1, show_default=True)
+def credits_limits_set(
+    project_dir: str,
+    provider: str,
+    model: str,
+    rpm_limit: int,
+    tpm_limit: int,
+    utilization_target: float,
+    concurrency_cap: int,
+) -> None:
+    """Create or replace a local model rate-limit profile."""
+    from specsmith.rate_limits import (
+        ModelRateLimitProfile,
+        load_rate_limit_profiles,
+        save_rate_limit_profiles,
+    )
+
+    root = Path(project_dir).resolve()
+    updated_profile = ModelRateLimitProfile(
+        provider=provider,
+        model=model,
+        rpm_limit=rpm_limit,
+        tpm_limit=tpm_limit,
+        utilization_target=utilization_target,
+        concurrency_cap=concurrency_cap,
+        source="override",
+    )
+    profiles = {profile.key: profile for profile in load_rate_limit_profiles(root)}
+    profiles[updated_profile.key] = updated_profile
+    save_rate_limit_profiles(root, list(profiles.values()))
+    console.print(
+        "[green]✓[/green] "
+        f"Saved {updated_profile.provider}/{updated_profile.model} "
+        f"(RPM={updated_profile.rpm_limit}, TPM={updated_profile.tpm_limit}, "
+        f"target={updated_profile.utilization_target:.2f}, "
+        f"concurrency={updated_profile.concurrency_cap})"
+    )
+
+
+@credits_limits.command(name="status")
+@click.option("--project-dir", type=click.Path(exists=True), default=".")
+@click.option("--provider", required=True, help="Provider key, such as openai or anthropic.")
+@click.option("--model", required=True, help="Model key, such as gpt-5.4.")
+def credits_limits_status(project_dir: str, provider: str, model: str) -> None:
+    """Show rolling-window snapshot for a model (RPM, TPM, concurrency, moving averages)."""
+    from specsmith.rate_limits import (
+        BUILTIN_PROFILES,
+        load_rate_limit_profiles,
+        load_rate_limit_scheduler,
+    )
+
+    root = Path(project_dir).resolve()
+    profiles = load_rate_limit_profiles(root, defaults=BUILTIN_PROFILES)
+    scheduler = load_rate_limit_scheduler(root, profiles)
+
+    try:
+        snap = scheduler.snapshot(provider, model)
+    except KeyError:
+        console.print(
+            f"[red]No profile found for {provider}/{model}.[/red] "
+            "Use 'specsmith credits limits set' to configure one."
+        )
+        raise SystemExit(1) from None
+
+    console.print(f"[bold]{snap.provider}/{snap.model}[/bold]")
+    console.print(
+        f"  RPM: {snap.rolling_request_count} / {snap.effective_rpm_limit} "
+        f"(limit {snap.rpm_limit}, target {snap.effective_rpm_limit})"
+    )
+    console.print(
+        f"  TPM: {snap.rolling_token_count:,} / {snap.effective_tpm_limit:,} "
+        f"(limit {snap.tpm_limit:,})"
+    )
+    console.print(
+        f"  Utilization: RPM {snap.request_utilization:.1%}  TPM {snap.token_utilization:.1%}"
+    )
+    console.print(
+        f"  Concurrency: {snap.in_flight} in-flight / {snap.current_concurrency_cap} cap "
+        f"(base {snap.base_concurrency_cap})"
+    )
+    console.print(
+        f"  Moving avg:  {snap.moving_average_requests:.1f} req/window  "
+        f"{snap.moving_average_tokens:,.0f} tok/window"
+    )
+
+
+@credits_limits.command(name="defaults")
+@click.option("--project-dir", type=click.Path(exists=True), default=".")
+@click.option(
+    "--install",
+    is_flag=True,
+    default=False,
+    help="Merge built-in defaults into the local project config (existing overrides preserved).",
+)
+def credits_limits_defaults(project_dir: str, install: bool) -> None:
+    """List (or install) built-in RPM/TPM profiles for common provider/model paths."""
+    from specsmith.rate_limits import (
+        BUILTIN_PROFILES,
+        load_rate_limit_profiles,
+        save_rate_limit_profiles,
+    )
+
+    console.print("[bold]Built-in model rate-limit profiles[/bold]")
+    console.print("[dim](conservative defaults — local overrides take precedence)[/dim]\n")
+    for profile in BUILTIN_PROFILES:
+        console.print(
+            f"  {profile.provider}/{profile.model:25s} "
+            f"RPM={profile.rpm_limit:<6} TPM={profile.tpm_limit:>12,} "
+            f"target={profile.utilization_target:.2f}"
+        )
+
+    if install:
+        root = Path(project_dir).resolve()
+        # Load existing local profiles; they take precedence over built-ins
+        existing = {p.key: p for p in load_rate_limit_profiles(root)}
+        merged = {p.key: p for p in BUILTIN_PROFILES}
+        merged.update(existing)  # local overrides win
+        save_rate_limit_profiles(root, list(merged.values()))
+        added = len(merged) - len(existing)
+        console.print(
+            f"\n[green]\u2713[/green] Installed {added} new default(s) to "
+            ".specsmith/model-rate-limits.json (existing profiles preserved)."
+        )
+
+
 main.add_command(credits)
 
 

specsmith/rate_limits.py

@@ -0,0 +1,784 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 BitConcepts, LLC. All rights reserved.
+"""Runtime model rate-limit profiles, pacing, and retry helpers."""
+
+from __future__ import annotations
+
+import json
+import math
+import random
+import re
+import time
+from collections import deque
+from collections.abc import Callable
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+_STATE_DIR = ".specsmith"
+_PROFILE_FILE = "model-rate-limits.json"
+_RUNTIME_STATE_FILE = "model-rate-limit-state.json"
+_ROLLING_WINDOW_SECONDS = 60.0
+_CONCURRENCY_POLL_SECONDS = 0.1
+_MOVING_AVERAGE_ALPHA = 0.25
+_RETRY_JITTER_RATIO = 0.2
+
+_WAIT_PATTERNS = (
+    re.compile(
+        r"please\s+try\s+again\s+in\s+(?P<value>\d+(?:\.\d+)?)\s*(?P<unit>ms|s|sec|secs|seconds)",
+        flags=re.IGNORECASE,
+    ),
+    re.compile(
+        r"retry\s+(?:after|in)\s+(?P<value>\d+(?:\.\d+)?)\s*(?P<unit>ms|s|sec|secs|seconds)",
+        flags=re.IGNORECASE,
+    ),
+)
+
+
+@dataclass(slots=True)
+class ModelRateLimitProfile:
+    """Rate-limit profile for a single provider/model path."""
+
+    provider: str
+    model: str
+    rpm_limit: int
+    tpm_limit: int
+    utilization_target: float = 0.7
+    concurrency_cap: int = 1
+    source: str = "local"
+
+    def __post_init__(self) -> None:
+        self.provider = _normalize_key_part(self.provider)
+        self.model = _normalize_key_part(self.model)
+        if self.rpm_limit <= 0:
+            raise ValueError("rpm_limit must be greater than zero")
+        if self.tpm_limit <= 0:
+            raise ValueError("tpm_limit must be greater than zero")
+        if not 0 < self.utilization_target <= 1:
+            raise ValueError("utilization_target must be greater than 0 and at most 1")
+        if self.concurrency_cap <= 0:
+            raise ValueError("concurrency_cap must be greater than zero")
+
+    @property
+    def key(self) -> str:
+        """Stable provider/model key."""
+        return _profile_key(self.provider, self.model)
+
+    @property
+    def effective_rpm_limit(self) -> int:
+        """Budgeted request ceiling after utilization target is applied."""
+        return max(1, int(math.floor(self.rpm_limit * self.utilization_target)))
+
+    @property
+    def effective_tpm_limit(self) -> int:
+        """Budgeted token ceiling after utilization target is applied."""
+        return max(1, int(math.floor(self.tpm_limit * self.utilization_target)))
+
+    def matches(self, provider: str, model: str) -> bool:
+        """Check if this profile applies to the given provider/model."""
+        provider = _normalize_key_part(provider)
+        model = _normalize_key_part(model)
+        provider_match = self.provider == "*" or self.provider == provider
+        model_match = self.model == "*" or self.model == model
+        return provider_match and model_match
+
+
+@dataclass(slots=True)
+class RateLimitReservation:
+    """A pre-dispatch budget reservation for a single request."""
+
+    reservation_id: str
+    provider: str
+    model: str
+    estimated_input_tokens: int
+    max_output_tokens: int
+    estimated_total_tokens: int
+    acquired_at: float
+    waited_seconds: float = 0.0
+
+
+@dataclass(slots=True)
+class RateLimitSnapshot:
+    """Current rolling-window and moving-average state for a model."""
+
+    provider: str
+    model: str
+    rpm_limit: int
+    tpm_limit: int
+    effective_rpm_limit: int
+    effective_tpm_limit: int
+    rolling_request_count: int
+    rolling_token_count: int
+    moving_average_requests: float
+    moving_average_tokens: float
+    request_utilization: float
+    token_utilization: float
+    base_concurrency_cap: int
+    current_concurrency_cap: int
+    in_flight: int
+
+
+@dataclass(slots=True)
+class RateLimitErrorDetails:
+    """Normalized provider rate-limit classification."""
+
+    is_rate_limit: bool
+    message: str
+    status_code: int | None = None
+    retry_after_seconds: float | None = None
+
+
+@dataclass(slots=True)
+class _TokenEvent:
+    timestamp: float
+    tokens: int
+    reservation_id: str
+
+
+@dataclass(slots=True)
+class _ModelRuntimeState:
+    request_timestamps: deque[float] = field(default_factory=deque)
+    token_events: deque[_TokenEvent] = field(default_factory=deque)
+    active_reservations: set[str] = field(default_factory=set)
+    in_flight: int = 0
+    current_concurrency_cap: int = 0
+    success_streak: int = 0
+    moving_average_requests: float = 0.0
+    moving_average_tokens: float = 0.0
+
+
+def _normalize_key_part(value: str) -> str:
+    return value.strip().lower()
+
+
+def _profile_key(provider: str, model: str) -> str:
+    return f"{_normalize_key_part(provider)}::{_normalize_key_part(model)}"
+
+
+def _get_profile_path(root: Path) -> Path:
+    path = root / _STATE_DIR / _PROFILE_FILE
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _get_runtime_state_path(root: Path) -> Path:
+    path = root / _STATE_DIR / _RUNTIME_STATE_FILE
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+# ---------------------------------------------------------------------------
+# Built-in provider/model defaults
+# ---------------------------------------------------------------------------
+# These are conservative starting points.  Account and tier limits vary.
+# Local overrides (saved in .specsmith/model-rate-limits.json) always take
+# precedence over these defaults — see load_rate_limit_profiles().
+
+
+def _default(  # noqa: PLR0913
+    provider: str,
+    model: str,
+    rpm: int,
+    tpm: int,
+    utilization_target: float = 0.7,
+    concurrency_cap: int = 1,
+) -> ModelRateLimitProfile:
+    return ModelRateLimitProfile(
+        provider=provider,
+        model=model,
+        rpm_limit=rpm,
+        tpm_limit=tpm,
+        utilization_target=utilization_target,
+        concurrency_cap=concurrency_cap,
+        source="default",
+    )
+
+
+BUILTIN_PROFILES: list[ModelRateLimitProfile] = [
+    # --- OpenAI ---
+    _default("openai", "gpt-4o", rpm=500, tpm=30_000_000),
+    _default("openai", "gpt-4o-mini", rpm=500, tpm=200_000_000),
+    _default("openai", "gpt-4-turbo", rpm=500, tpm=800_000),
+    _default("openai", "gpt-3.5-turbo", rpm=3500, tpm=90_000),
+    _default("openai", "o1", rpm=500, tpm=30_000_000),
+    _default("openai", "o1-mini", rpm=1000, tpm=200_000_000),
+    _default("openai", "o3-mini", rpm=1000, tpm=200_000_000),
+    # gpt-5.4 — org quota from issue #59 example: 500K TPM
+    _default("openai", "gpt-5.4", rpm=60, tpm=500_000),
+    # Wildcard fallback for unknown OpenAI models
+    _default("openai", "*", rpm=500, tpm=500_000),
+    # --- Anthropic ---
+    _default("anthropic", "claude-opus-4", rpm=2000, tpm=40_000_000),
+    _default("anthropic", "claude-sonnet-4", rpm=2000, tpm=40_000_000),
+    _default("anthropic", "claude-haiku-3-5", rpm=2000, tpm=200_000_000),
+    _default("anthropic", "claude-3-5-sonnet", rpm=2000, tpm=40_000_000),
+    _default("anthropic", "claude-3-5-haiku", rpm=2000, tpm=200_000_000),
+    _default("anthropic", "claude-3-opus", rpm=2000, tpm=40_000_000),
+    # Wildcard fallback for unknown Anthropic models
+    _default("anthropic", "*", rpm=2000, tpm=40_000_000),
+    # --- Google ---
+    _default("google", "gemini-1.5-pro", rpm=360, tpm=4_000_000),
+    _default("google", "gemini-1.5-flash", rpm=1000, tpm=4_000_000),
+    _default("google", "gemini-2.0-flash", rpm=1000, tpm=4_000_000),
+    _default("google", "gemini-2.5-pro", rpm=360, tpm=4_000_000),
+    # Wildcard fallback for unknown Google models
+    _default("google", "*", rpm=360, tpm=4_000_000),
+]
+"""Conservative built-in RPM/TPM profiles for common provider/model paths.
+
+Use ``specsmith credits limits defaults`` to inspect these values or install
+them into a project's local override file.
+"""
+
+
+def save_rate_limit_profiles(root: Path, profiles: list[ModelRateLimitProfile]) -> None:
+    """Persist local rate-limit profiles."""
+    path = _get_profile_path(root)
+    path.write_text(
+        json.dumps([asdict(profile) for profile in profiles], indent=2),
+        encoding="utf-8",
+    )
+
+
+def load_rate_limit_profiles(
+    root: Path,
+    *,
+    defaults: list[ModelRateLimitProfile] | None = None,
+) -> list[ModelRateLimitProfile]:
+    """Load local profiles, overriding any provided defaults by provider/model key."""
+    merged = {profile.key: profile for profile in defaults or []}
+    path = _get_profile_path(root)
+    if not path.exists():
+        return list(merged.values())
+
+    try:
+        raw_profiles = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return list(merged.values())
+
+    for item in raw_profiles:
+        profile = ModelRateLimitProfile(**item)
+        merged[profile.key] = profile
+    return list(merged.values())
+
+
+def classify_rate_limit_error(error: object) -> RateLimitErrorDetails:
+    """Normalize provider-specific 429/rate-limit failures."""
+    status_code = _extract_status_code(error)
+    message = _extract_message(error)
+    headers = _extract_headers(error)
+
+    retry_after = _parse_retry_after_headers(headers)
+    if retry_after is None:
+        retry_after = _parse_retry_after_message(message)
+
+    message_lower = message.lower()
+    code = _extract_error_code(error)
+    is_rate_limit = bool(
+        status_code == 429
+        or code in {"rate_limit_exceeded", "rate_limited"}
+        or "rate limit" in message_lower
+        or "too many requests" in message_lower
+    )
+
+    return RateLimitErrorDetails(
+        is_rate_limit=is_rate_limit,
+        message=message,
+        status_code=status_code,
+        retry_after_seconds=retry_after,
+    )
+
+
+def compute_retry_delay(
+    error: object,
+    attempt: int,
+    *,
+    base_delay_seconds: float = 1.0,
+    max_delay_seconds: float = 60.0,
+    random_fn: Callable[[], float] | None = None,
+) -> float:
+    """Return provider-prescribed wait or exponential backoff plus jitter."""
+    details = classify_rate_limit_error(error)
+    if details.retry_after_seconds is not None:
+        return details.retry_after_seconds
+
+    jitter_source = random_fn or random.random
+    backoff = min(max_delay_seconds, base_delay_seconds * (2 ** max(attempt - 1, 0)))
+    return float(backoff + (backoff * _RETRY_JITTER_RATIO * jitter_source()))
+
+
+class RateLimitScheduler:
+    """Rolling-window model scheduler with pacing and adaptive concurrency."""
+
+    def __init__(
+        self,
+        profiles: list[ModelRateLimitProfile],
+        *,
+        clock: Callable[[], float] | None = None,
+        sleep_fn: Callable[[float], None] | None = None,
+        random_fn: Callable[[], float] | None = None,
+        window_seconds: float = _ROLLING_WINDOW_SECONDS,
+        restore_after_successes: int = 3,
+        concurrency_poll_seconds: float = _CONCURRENCY_POLL_SECONDS,
+    ) -> None:
+        self._profiles = {profile.key: profile for profile in profiles}
+        self._states: dict[str, _ModelRuntimeState] = {}
+        self._reservations: dict[str, RateLimitReservation] = {}
+        self._clock = clock or time.monotonic
+        self._sleep_fn = sleep_fn or time.sleep
+        self._random_fn = random_fn or random.random
+        self._window_seconds = window_seconds
+        self._restore_after_successes = restore_after_successes
+        self._concurrency_poll_seconds = concurrency_poll_seconds
+        self._reservation_counter = 0
+
+    def upsert_profiles(self, profiles: list[ModelRateLimitProfile]) -> None:
+        """Add or replace profiles by provider/model key."""
+        for profile in profiles:
+            self._profiles[profile.key] = profile
+
+    def acquire(
+        self,
+        provider: str,
+        model: str,
+        *,
+        estimated_input_tokens: int,
+        max_output_tokens: int,
+    ) -> RateLimitReservation:
+        """Block until RPM/TPM budget and concurrency are available."""
+        profile = self._resolve_profile(provider, model)
+        state = self._get_state(profile)
+        waited_seconds = 0.0
+        estimated_total_tokens = max(0, estimated_input_tokens) + max(0, max_output_tokens)
+
+        while True:
+            now = self._clock()
+            self._purge_expired(state, now)
+            wait_seconds = self._compute_wait_seconds(state, profile, estimated_total_tokens, now)
+            if wait_seconds <= 0:
+                break
+            self._sleep_fn(wait_seconds)
+            waited_seconds += wait_seconds
+
+        now = self._clock()
+        reservation = RateLimitReservation(
+            reservation_id=self._next_reservation_id(),
+            provider=profile.provider,
+            model=profile.model,
+            estimated_input_tokens=max(0, estimated_input_tokens),
+            max_output_tokens=max(0, max_output_tokens),
+            estimated_total_tokens=estimated_total_tokens,
+            acquired_at=now,
+            waited_seconds=waited_seconds,
+        )
+        state.request_timestamps.append(now)
+        state.token_events.append(
+            _TokenEvent(
+                timestamp=now,
+                tokens=estimated_total_tokens,
+                reservation_id=reservation.reservation_id,
+            )
+        )
+        state.active_reservations.add(reservation.reservation_id)
+        state.in_flight += 1
+        self._reservations[reservation.reservation_id] = reservation
+        self._update_moving_averages(state)
+        return reservation
+
+    def record_success(
+        self,
+        reservation: RateLimitReservation | str,
+        *,
+        actual_input_tokens: int | None = None,
+        actual_output_tokens: int | None = None,
+    ) -> RateLimitSnapshot:
+        """Finalize a successful request and optionally reconcile token estimate."""
+        reservation = self._coerce_reservation(reservation)
+        profile = self._resolve_profile(reservation.provider, reservation.model)
+        state = self._get_state(profile)
+        actual_total_tokens = reservation.estimated_total_tokens
+        if actual_input_tokens is not None or actual_output_tokens is not None:
+            actual_total_tokens = max(0, actual_input_tokens or 0) + max(
+                0, actual_output_tokens or 0
+            )
+            self._update_token_event(state, reservation.reservation_id, actual_total_tokens)
+
+        self._release_reservation(state, reservation.reservation_id)
+        if state.current_concurrency_cap < profile.concurrency_cap:
+            state.success_streak += 1
+            if state.success_streak >= self._restore_after_successes:
+                state.current_concurrency_cap += 1
+                state.success_streak = 0
+        self._update_moving_averages(state)
+        _ = actual_total_tokens
+        return self.snapshot(profile.provider, profile.model)
+
+    def record_rate_limit(
+        self,
+        reservation: RateLimitReservation | str,
+        error: object,
+        *,
+        attempt: int,
+    ) -> float:
+        """Apply concurrency reduction and return the delay before retry."""
+        reservation = self._coerce_reservation(reservation)
+        profile = self._resolve_profile(reservation.provider, reservation.model)
+        state = self._get_state(profile)
+        self._release_reservation(state, reservation.reservation_id)
+        state.success_streak = 0
+        state.current_concurrency_cap = max(1, math.ceil(state.current_concurrency_cap / 2))
+        self._update_moving_averages(state)
+        return compute_retry_delay(error, attempt, random_fn=self._random_fn)
+
+    def get_reservation(self, reservation_id: str) -> RateLimitReservation:
+        """Get an active reservation by identifier."""
+        if reservation_id not in self._reservations:
+            raise KeyError(f"Unknown reservation id: {reservation_id}")
+        return self._reservations[reservation_id]
+
+    def snapshot(self, provider: str, model: str) -> RateLimitSnapshot:
+        """Get rolling-window and concurrency state for a provider/model."""
+        profile = self._resolve_profile(provider, model)
+        state = self._get_state(profile)
+        self._purge_expired(state, self._clock())
+        rolling_requests = len(state.request_timestamps)
+        rolling_tokens = sum(event.tokens for event in state.token_events)
+        self._update_moving_averages(state)
+        return RateLimitSnapshot(
+            provider=profile.provider,
+            model=profile.model,
+            rpm_limit=profile.rpm_limit,
+            tpm_limit=profile.tpm_limit,
+            effective_rpm_limit=profile.effective_rpm_limit,
+            effective_tpm_limit=profile.effective_tpm_limit,
+            rolling_request_count=rolling_requests,
+            rolling_token_count=rolling_tokens,
+            moving_average_requests=state.moving_average_requests,
+            moving_average_tokens=state.moving_average_tokens,
+            request_utilization=rolling_requests / profile.effective_rpm_limit,
+            token_utilization=rolling_tokens / profile.effective_tpm_limit,
+            base_concurrency_cap=profile.concurrency_cap,
+            current_concurrency_cap=state.current_concurrency_cap,
+            in_flight=state.in_flight,
+        )
+
+    def _resolve_profile(self, provider: str, model: str) -> ModelRateLimitProfile:
+        provider = _normalize_key_part(provider)
+        model = _normalize_key_part(model)
+        exact_key = _profile_key(provider, model)
+        if exact_key in self._profiles:
+            return self._profiles[exact_key]
+
+        for wildcard_key in (
+            _profile_key(provider, "*"),
+            _profile_key("*", model),
+            _profile_key("*", "*"),
+        ):
+            if wildcard_key in self._profiles:
+                return self._profiles[wildcard_key]
+
+        raise KeyError(f"No rate-limit profile configured for {provider}/{model}")
+
+    def _get_state(self, profile: ModelRateLimitProfile) -> _ModelRuntimeState:
+        if profile.key not in self._states:
+            self._states[profile.key] = _ModelRuntimeState(
+                current_concurrency_cap=profile.concurrency_cap
+            )
+        return self._states[profile.key]
+
+    def _compute_wait_seconds(
+        self,
+        state: _ModelRuntimeState,
+        profile: ModelRateLimitProfile,
+        estimated_total_tokens: int,
+        now: float,
+    ) -> float:
+        request_wait = 0.0
+        if len(state.request_timestamps) + 1 > profile.effective_rpm_limit:
+            oldest_request = state.request_timestamps[0]
+            request_wait = max(0.0, oldest_request + self._window_seconds - now)
+
+        token_wait = self._compute_token_wait_seconds(
+            state=state,
+            token_limit=profile.effective_tpm_limit,
+            estimated_total_tokens=estimated_total_tokens,
+            now=now,
+        )
+
+        concurrency_wait = (
+            self._concurrency_poll_seconds
+            if state.in_flight >= state.current_concurrency_cap
+            else 0.0
+        )
+        return max(request_wait, token_wait, concurrency_wait)
+
+    def _compute_token_wait_seconds(
+        self,
+        *,
+        state: _ModelRuntimeState,
+        token_limit: int,
+        estimated_total_tokens: int,
+        now: float,
+    ) -> float:
+        current_tokens = sum(event.tokens for event in state.token_events)
+        if current_tokens + estimated_total_tokens <= token_limit:
+            return 0.0
+
+        tokens_to_free = current_tokens + estimated_total_tokens - token_limit
+        freed_tokens = 0
+        wait_seconds = 0.0
+        for event in state.token_events:
+            freed_tokens += event.tokens
+            wait_seconds = max(0.0, event.timestamp + self._window_seconds - now)
+            if freed_tokens >= tokens_to_free:
+                return wait_seconds
+        return self._window_seconds
+
+    def _purge_expired(self, state: _ModelRuntimeState, now: float) -> None:
+        cutoff = now - self._window_seconds
+        while state.request_timestamps and state.request_timestamps[0] <= cutoff:
+            state.request_timestamps.popleft()
+        while state.token_events and state.token_events[0].timestamp <= cutoff:
+            state.token_events.popleft()
+
+    def _release_reservation(self, state: _ModelRuntimeState, reservation_id: str) -> None:
+        if reservation_id in state.active_reservations:
+            state.active_reservations.remove(reservation_id)
+            state.in_flight = max(0, state.in_flight - 1)
+        self._reservations.pop(reservation_id, None)
+
+    def _update_token_event(
+        self,
+        state: _ModelRuntimeState,
+        reservation_id: str,
+        actual_total_tokens: int,
+    ) -> None:
+        for event in state.token_events:
+            if event.reservation_id == reservation_id:
+                event.tokens = actual_total_tokens
+                break
+
+    def _update_moving_averages(self, state: _ModelRuntimeState) -> None:
+        current_requests = float(len(state.request_timestamps))
+        current_tokens = float(sum(event.tokens for event in state.token_events))
+        state.moving_average_requests = (_MOVING_AVERAGE_ALPHA * current_requests) + (
+            (1 - _MOVING_AVERAGE_ALPHA) * state.moving_average_requests
+        )
+        state.moving_average_tokens = (_MOVING_AVERAGE_ALPHA * current_tokens) + (
+            (1 - _MOVING_AVERAGE_ALPHA) * state.moving_average_tokens
+        )
+
+    def _next_reservation_id(self) -> str:
+        self._reservation_counter += 1
+        return f"reservation-{self._reservation_counter}"
+
+    def export_state(self) -> dict[str, object]:
+        """Serialize the scheduler state for persistence."""
+        now = self._clock()
+        states: dict[str, object] = {}
+        for key, state in self._states.items():
+            self._purge_expired(state, now)
+            self._update_moving_averages(state)
+            states[key] = {
+                "request_timestamps": list(state.request_timestamps),
+                "token_events": [
+                    {
+                        "timestamp": event.timestamp,
+                        "tokens": event.tokens,
+                        "reservation_id": event.reservation_id,
+                    }
+                    for event in state.token_events
+                ],
+                "active_reservations": sorted(state.active_reservations),
+                "in_flight": state.in_flight,
+                "current_concurrency_cap": state.current_concurrency_cap,
+                "success_streak": state.success_streak,
+                "moving_average_requests": state.moving_average_requests,
+                "moving_average_tokens": state.moving_average_tokens,
+            }
+
+        return {
+            "states": states,
+            "reservations": {
+                reservation_id: asdict(reservation)
+                for reservation_id, reservation in self._reservations.items()
+            },
+            "reservation_counter": self._reservation_counter,
+        }
+
+    def import_state(self, data: dict[str, object]) -> None:
+        """Restore scheduler state from persistence."""
+        self._states = {}
+        raw_states = data.get("states", {})
+        if isinstance(raw_states, dict):
+            for key, raw_state in raw_states.items():
+                if not isinstance(raw_state, dict):
+                    continue
+                token_events: deque[_TokenEvent] = deque()
+                for raw_event in raw_state.get("token_events", []):
+                    if not isinstance(raw_event, dict):
+                        continue
+                    token_events.append(
+                        _TokenEvent(
+                            timestamp=float(raw_event["timestamp"]),
+                            tokens=int(raw_event["tokens"]),
+                            reservation_id=str(raw_event["reservation_id"]),
+                        )
+                    )
+                self._states[str(key)] = _ModelRuntimeState(
+                    request_timestamps=deque(
+                        float(timestamp) for timestamp in raw_state.get("request_timestamps", [])
+                    ),
+                    token_events=token_events,
+                    active_reservations=set(
+                        str(reservation_id)
+                        for reservation_id in raw_state.get("active_reservations", [])
+                    ),
+                    in_flight=int(raw_state.get("in_flight", 0)),
+                    current_concurrency_cap=int(raw_state.get("current_concurrency_cap", 0)),
+                    success_streak=int(raw_state.get("success_streak", 0)),
+                    moving_average_requests=float(raw_state.get("moving_average_requests", 0.0)),
+                    moving_average_tokens=float(raw_state.get("moving_average_tokens", 0.0)),
+                )
+
+        self._reservations = {}
+        raw_reservations = data.get("reservations", {})
+        if isinstance(raw_reservations, dict):
+            for reservation_id, raw_reservation in raw_reservations.items():
+                if not isinstance(raw_reservation, dict):
+                    continue
+                reservation = RateLimitReservation(**raw_reservation)
+                self._reservations[str(reservation_id)] = reservation
+
+        reservation_counter = data.get("reservation_counter", 0)
+        if isinstance(reservation_counter, int):
+            self._reservation_counter = reservation_counter
+
+    def _coerce_reservation(self, reservation: RateLimitReservation | str) -> RateLimitReservation:
+        if isinstance(reservation, RateLimitReservation):
+            return reservation
+        return self.get_reservation(reservation)
+
+
+def _extract_status_code(error: object) -> int | None:
+    status_code = getattr(error, "status_code", None)
+    if isinstance(status_code, int):
+        return status_code
+
+    response = getattr(error, "response", None)
+    response_status = getattr(response, "status_code", None)
+    if isinstance(response_status, int):
+        return response_status
+    return None
+
+
+def _extract_headers(error: object) -> dict[str, str]:
+    response = getattr(error, "response", None)
+    headers = getattr(response, "headers", None)
+    if isinstance(headers, dict):
+        return {str(k).lower(): str(v) for k, v in headers.items()}
+    if isinstance(error, dict):
+        raw_headers = error.get("headers")
+        if isinstance(raw_headers, dict):
+            return {str(k).lower(): str(v) for k, v in raw_headers.items()}
+    return {}
+
+
+def _extract_message(error: object) -> str:
+    if isinstance(error, str):
+        return error
+    if isinstance(error, dict):
+        parts: list[str] = []
+        for key in ("message", "detail", "error"):
+            value = error.get(key)
+            if isinstance(value, str):
+                parts.append(value)
+        if parts:
+            return " ".join(parts)
+        return json.dumps(error)
+    message = getattr(error, "message", None)
+    if isinstance(message, str) and message:
+        return message
+    args = getattr(error, "args", ())
+    if args:
+        return " ".join(str(arg) for arg in args if arg)
+    return str(error)
+
+
+def _extract_error_code(error: object) -> str | None:
+    if isinstance(error, dict):
+        code = error.get("code")
+        if isinstance(code, str):
+            return code.lower()
+    code = getattr(error, "code", None)
+    if isinstance(code, str):
+        return code.lower()
+    return None
+
+
+def _parse_retry_after_headers(headers: dict[str, str]) -> float | None:
+    for key in ("retry-after", "retry-after-ms", "x-ratelimit-reset-after"):
+        value = headers.get(key)
+        if value is None:
+            continue
+        try:
+            numeric = float(value)
+        except ValueError:
+            continue
+        if key == "retry-after-ms":
+            return numeric / 1000.0
+        return numeric
+    return None
+
+
+def _parse_retry_after_message(message: str) -> float | None:
+    for pattern in _WAIT_PATTERNS:
+        match = pattern.search(message)
+        if not match:
+            continue
+        value = float(match.group("value"))
+        unit = match.group("unit").lower()
+        if unit == "ms":
+            return value / 1000.0
+        return value
+    return None
+
+
+def load_rate_limit_scheduler(
+    root: Path,
+    profiles: list[ModelRateLimitProfile],
+    *,
+    clock: Callable[[], float] | None = None,
+    sleep_fn: Callable[[float], None] | None = None,
+    random_fn: Callable[[], float] | None = None,
+    window_seconds: float = _ROLLING_WINDOW_SECONDS,
+    restore_after_successes: int = 3,
+    concurrency_poll_seconds: float = _CONCURRENCY_POLL_SECONDS,
+) -> RateLimitScheduler:
+    """Build a scheduler and hydrate any saved runtime state."""
+    scheduler = RateLimitScheduler(
+        profiles,
+        clock=clock,
+        sleep_fn=sleep_fn,
+        random_fn=random_fn,
+        window_seconds=window_seconds,
+        restore_after_successes=restore_after_successes,
+        concurrency_poll_seconds=concurrency_poll_seconds,
+    )
+    path = _get_runtime_state_path(root)
+    if not path.exists():
+        return scheduler
+
+    try:
+        raw_state = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return scheduler
+
+    if isinstance(raw_state, dict):
+        scheduler.import_state(raw_state)
+    return scheduler
+
+
+def save_rate_limit_scheduler(root: Path, scheduler: RateLimitScheduler) -> None:
+    """Persist current runtime scheduler state."""
+    path = _get_runtime_state_path(root)
+    path.write_text(json.dumps(scheduler.export_state(), indent=2), encoding="utf-8")

specsmith/templates/governance/rules.md.j2

@@ -34,6 +34,18 @@ All agent-invoked commands MUST have a timeout. No command may run indefinitely.
 ### H10 — No hardcoded versions
 Version strings MUST NOT be hardcoded in documentation, tests, or source code outside of `pyproject.toml`. Use `importlib.metadata.version()` at runtime. Use `{{ "{{ version }}" }}` placeholders in documentation resolved at build time.
 
+### H11 — No unbounded loops or blocking I/O without a deadline
+Every loop or blocking wait in agent-written scripts and automation MUST have:
+
+- An explicit deadline or iteration cap (e.g. a `deadline` timestamp, a `max_attempts` counter, or a `timeout` parameter).
+- A fallback exit path that executes when the deadline is reached.
+- A diagnostic message emitted if the timeout fires (self-diagnosing failures).
+
+Examples of violating patterns: `while True:` / `while ($true)` / `for (;;)` with no deadline guard; serial-port or I/O polling loops with no deadline; `sleep` inside a loop with no termination condition. `specsmith validate` checks scripts under `scripts/` for these patterns.
+
+### H12 — Windows multi-step automation via .cmd files
+On Windows, multi-step or heavily-quoted automation sequences MUST be written to a temporary `.cmd` file and executed from there. Do NOT emit these as inline shell invocations or as `.ps1` files unless there is a concrete PowerShell-only requirement. Inline multi-line quoting on Windows is fragile and causes avoidable hangs.
+
 ---
 
 ## Stop Conditions

specsmith/validator.py

@@ -39,6 +39,30 @@ class ValidationReport:
 
 _REQ_PATTERN = re.compile(r"\b(REQ-[A-Z]+-\d+)\b")
 
+# Infinite-loop patterns (Python, PowerShell, shell)
+_INFINITE_LOOP_PATTERNS = (
+    re.compile(r"while\s+True\s*:"),  # Python
+    re.compile(r"while\s*\(\s*\$true\s*\)", re.IGNORECASE),  # PowerShell
+    re.compile(r"while\s+true\s*[;{]", re.IGNORECASE),  # bash/sh
+    re.compile(r"while\s+:\s*[;{\n]"),  # bash/sh `while :`
+    re.compile(r"for\s*\(\s*;;\s*\)"),  # C-style for(;;)
+)
+
+# Deadline/timeout guard keywords — presence anywhere in the file suppresses the warning
+_DEADLINE_GUARD_PATTERNS = (
+    re.compile(r"deadline", re.IGNORECASE),
+    re.compile(r"timeout", re.IGNORECASE),
+    re.compile(r"max_iter", re.IGNORECASE),
+    re.compile(r"max_attempt", re.IGNORECASE),
+    re.compile(r"time\.monotonic\("),
+    re.compile(r"time\.time\("),
+    re.compile(r"Get-Date", re.IGNORECASE),
+    re.compile(r"\$SECONDS"),
+)
+
+# Script file extensions to scan (exclude general source dirs to avoid false positives)
+_SCRIPT_EXTENSIONS = {".sh", ".cmd", ".ps1", ".bash"}
+
 
 def _check_scaffold_yml(root: Path) -> list[ValidationResult]:
     """Check that scaffold.yml exists and is valid YAML."""
@@ -208,6 +232,74 @@ def _check_architecture_reqs(root: Path) -> list[ValidationResult]:
     return results
 
 
+def _check_blocking_loops(root: Path) -> list[ValidationResult]:
+    """Scan script files for unbounded loops without a deadline/timeout guard.
+
+    Checks .sh, .cmd, .ps1, .bash files under scripts/ and the project root.
+    A file is flagged only when it contains an infinite-loop pattern AND lacks
+    any recognised deadline/timeout guard anywhere in the file body.
+    This is a heuristic check; results are warnings rather than hard failures.
+    """
+    results: list[ValidationResult] = []
+
+    # Collect script files: root-level + scripts/ subdirectory
+    candidates: list[Path] = []
+    for path in root.iterdir():
+        if path.is_file() and path.suffix.lower() in _SCRIPT_EXTENSIONS:
+            candidates.append(path)
+    scripts_dir = root / "scripts"
+    if scripts_dir.is_dir():
+        for path in scripts_dir.rglob("*"):
+            if path.is_file() and path.suffix.lower() in _SCRIPT_EXTENSIONS:
+                candidates.append(path)
+
+    if not candidates:
+        return results
+
+    flagged: list[str] = []
+    for script_path in candidates:
+        try:
+            text = script_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+
+        has_infinite_loop = any(p.search(text) for p in _INFINITE_LOOP_PATTERNS)
+        if not has_infinite_loop:
+            continue
+
+        has_deadline_guard = any(p.search(text) for p in _DEADLINE_GUARD_PATTERNS)
+        if not has_deadline_guard:
+            try:
+                rel = script_path.relative_to(root)
+            except ValueError:
+                rel = script_path
+            flagged.append(str(rel))
+
+    if flagged:
+        for name in flagged:
+            results.append(
+                ValidationResult(
+                    name=f"blocking-loop:{name}",
+                    passed=False,
+                    message=(
+                        f"{name}: unbounded loop detected without a deadline/timeout guard "
+                        "(H11 violation). Add an explicit deadline, iteration cap, and "
+                        "fallback exit path."
+                    ),
+                )
+            )
+    else:
+        results.append(
+            ValidationResult(
+                name="blocking-loops",
+                passed=True,
+                message=f"{len(candidates)} script file(s) checked — no unbounded loops found",
+            )
+        )
+
+    return results
+
+
 def run_validate(root: Path) -> ValidationReport:
     """Run all validation checks and return a report."""
     report = ValidationReport()
@@ -215,4 +307,5 @@ def run_validate(root: Path) -> ValidationReport:
     report.results.extend(_check_agents_md_refs(root))
     report.results.extend(_check_req_ids_unique(root))
     report.results.extend(_check_architecture_reqs(root))
+    report.results.extend(_check_blocking_loops(root))
     return report

{specsmith-0.2.3.dev51.dist-info → specsmith-0.2.3.dev55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.2.3.dev51
+Version: 0.2.3.dev55
 Summary: Forge governed project scaffolds from the Agentic AI Development Workflow Specification.
 Author: BitConcepts
 License: MIT
@@ -129,7 +129,7 @@ Each type gets: tool-aware CI (correct lint/test/security/build tools), domain-s
 | `import` | Adopt an existing project (merge mode) |
 | `audit` | Drift detection and health checks (`--fix` to auto-repair) |
 | `architect` | Interactive architecture generation |
-| `validate` | Governance file consistency checks |
+| `validate` | Governance consistency + H11 blocking-loop detection |
 | `compress` | Archive old ledger entries |
 | `upgrade` | Update governance to new spec version |
 | `status` | CI/PR/alert status from VCS platform |
@@ -137,7 +137,13 @@ Each type gets: tool-aware CI (correct lint/test/security/build tools), domain-s
 | `export` | Compliance report with REQ↔TEST coverage |
 | `doctor` | Check if verification tools are installed |
 | `self-update` | Update specsmith (channel-aware) |
-| `credits` | AI credit tracking, analysis, and budgets |
+| `credits` | AI credit tracking, analysis, budgets, and rate-limit pacing |
+| `exec` / `ps` / `abort` | Tracked process execution with PID tracking and timeout |
+| `commit` / `push` / `sync` | Governance-aware VCS operations |
+| `branch` / `pr` | Strategy-aware branching and PR creation |
+| `ledger` | Structured ledger add/list/stats |
+| `req` | Requirements list/add/trace/gaps/orphans |
+| `session-end` | End-of-session checklist |
 
 ## 7 Agent Integrations
 
@@ -147,9 +153,36 @@ AGENTS.md (cross-platform standard), Warp/Oz, Claude Code, GitHub Copilot, Curso
 
 GitHub Actions, GitLab CI, Bitbucket Pipelines — all with tool-aware CI generated from the verification tool registry. Dependabot/Renovate configured per language ecosystem.
 
+## Governance Rules (H1–H12)
+
+specsmith-governed projects enforce 12 hard rules. Two were added in v0.2.3 for agentic workflows:
+
+- **H11** — Every loop or blocking wait in agent-written scripts must have a deadline, a fallback exit, and a diagnostic message on timeout. `specsmith validate` enforces this automatically.
+- **H12** — On Windows, multi-step automation goes into a `.cmd` file, not inline shell invocations or `.ps1` files.
+
+See [Governance Model](https://specsmith.readthedocs.io/en/stable/governance/) for the full rule set.
+
+## Proactive Rate Limit Pacing
+
+specsmith ships a rolling-window scheduler that paces AI provider requests before dispatch:
+
+- Built-in RPM/TPM profiles for OpenAI, Anthropic, and Google models (including wildcard fallbacks)
+- Pre-dispatch budget check: sleeps until the 60-second window refills instead of overshooting
+- Parses OpenAI-style `"Please try again in 10.793s"` messages and obeys them
+- Adaptive concurrency: halved after a 429, gradually restored after consecutive successes
+- Local overrides always take precedence over built-in defaults
+
+```bash
+specsmith credits limits defaults          # list built-in profiles
+specsmith credits limits defaults --install  # merge into project config
+specsmith credits limits status --provider openai --model gpt-5.4
+```
+
+See [Rate Limit Pacing](https://specsmith.readthedocs.io/en/stable/rate-limits/) for full details.
+
 ## Documentation
 
-**[specsmith.readthedocs.io](https://specsmith.readthedocs.io)** — Full user manual with tutorials, command reference, project type details, tool registry, governance model, troubleshooting.
+**[specsmith.readthedocs.io](https://specsmith.readthedocs.io)** — Full user manual with tutorials, command reference, project type details, tool registry, governance model, rate-limit pacing, troubleshooting.
 
 ## Links
 

{specsmith-0.2.3.dev51.dist-info → specsmith-0.2.3.dev55.dist-info}/RECORD

@@ -1,8 +1,8 @@
-specsmith/__init__.py,sha256=qoRmTGyIq0Tiw4ejj0FTwdtAVEyGeZ6LfNCqWbhWjdU,402
+specsmith/__init__.py,sha256=VI4gLAUb2VPV4nYai2qNB2ougBPMBOutVULWUVZ_Z-g,402
 specsmith/__main__.py,sha256=OEU30g2x5ATD1bzoo7iwwj6tST_41sgGnwPIK5dF6ao,189
 specsmith/architect.py,sha256=7lOy8PXCYMAmt6TmH25oMTvPTWke_ZC2ekjNjcuD9Zg,5439
 specsmith/auditor.py,sha256=ENpDtxI3BMsEgiY8NWi-O_0y1wvVVfoT9xUYlWzgNvw,20346
-specsmith/cli.py,sha256=eMOdEAvtdHvCuIj8-dwXKLH-wXWodLtJhqlX6_BbAXo,60215
+specsmith/cli.py,sha256=9-kglxR5AP7HMKFZMpV1gN-wkVb5mtBN8YdRJAbWMy0,66578
 specsmith/compressor.py,sha256=IqMF6WZMbqyA0KLQmBxRyM6xZF0g34-9lQxWcYz3tFs,4448
 specsmith/config.py,sha256=TCQ5LC9guFFLhLO028l5vp_dfpyfpgvbNFVTvWDEnds,9784
 specsmith/credit_analyzer.py,sha256=InobNXNzgM6dafYopKPJ7Vmod0M6wjv-TsXbxi36SbY,7052
@@ -14,6 +14,7 @@ specsmith/exporter.py,sha256=HKkSOA9JZ9vzb5498pFKxjcigv0yu6_T69yKy0FX4EQ,5780
 specsmith/importer.py,sha256=njw6Gi0gPhzpb28czH2V2nEPRIQKIe-TVZvaY73QAzI,40784
 specsmith/ledger.py,sha256=Ge6npHZo09rcoflbbvYU3EO1WN2JiZ6wJ7FktFxmq5I,2473
 specsmith/plugins.py,sha256=QE31Lpex1nIQ_ZO967j_m3YOfExWYRxbzJGiyFA_v9M,2099
+specsmith/rate_limits.py,sha256=1ebGpMFCFvGNl6O-9YpfW3BM8_3pgGzvxNNjacgBB8I,29406
 specsmith/releaser.py,sha256=wULrJlm9T2rQVctR0xtCt5-6BPlM2FO2zNZg2mszP0I,3569
 specsmith/requirements.py,sha256=YidhhfkQGxWAXIg8PDW3j2pRXaqERCZU5Cn_TaYVaGY,4044
 specsmith/scaffolder.py,sha256=gk-3U-2iOsHSAPwUDtFX_QuY9AO-T-9GjLTGwvKUTuw,15017
@@ -21,7 +22,7 @@ specsmith/session.py,sha256=Q3yN6ldDfcEOWUiMntvgpMdc9dB6yxUe52Vbb2Fd50Y,4481
 specsmith/tools.py,sha256=922vA1vqZLf8JwgMvd_qDnS3u8jDTXCUuLLSN-k7u_g,13205
 specsmith/updater.py,sha256=egv6QmYswjb8bvlYTNG71SKCHf507_9haHR1VJXCtjc,5235
 specsmith/upgrader.py,sha256=Hvjowhg2leGHRQMdF0enHwvJhh8I45UFAX64YkL3jLM,12790
-specsmith/validator.py,sha256=JHwDbdETQwPlV50kyk4h89VekOSL6XNRjCbUiB5-daE,6344
+specsmith/validator.py,sha256=rZ2klbBVgO_RZ8d1Ff0t4tfPQ92B8ncdBHavciIgIAQ,9791
 specsmith/vcs_commands.py,sha256=xDJb6FsREPQ8waF1rq5_KMxc8P1Gh9YrIUSjCitMnAU,10245
 specsmith/commands/__init__.py,sha256=NYHgaRqsMP_H_D6D7ETrlKQTUt-QHBHfr_kD0q8b0VI,132
 specsmith/integrations/__init__.py,sha256=K2Rfb1xhrqHQUqhpw4v2DJuoIvZJ3W0QTKsTCRTQjQ0,1627
@@ -58,7 +59,7 @@ specsmith/templates/go/main.go.j2,sha256=CbjkeC4vx8H5uqIS9x0-2DpWN7Id0YJw52KTbjX
 specsmith/templates/governance/context-budget.md.j2,sha256=jqrNcufKRD3D6bpqRULzgnD5ORsZuRVzprB4g_YOX5M,2451
 specsmith/templates/governance/drift-metrics.md.j2,sha256=XianRFmioDLzKWRkfDZjnf5dhGkIXzNsNBusCq6XTBc,1557
 specsmith/templates/governance/roles.md.j2,sha256=hTdeTgvv7voTvTyQgLZ08Ildwgy21Xl0p0Oo0bDhNdA,1075
-specsmith/templates/governance/rules.md.j2,sha256=e9735eU5HOWi3P_OUZhMT0mYcMb9vylE_Lu2yIq3gTk,2115
+specsmith/templates/governance/rules.md.j2,sha256=H-hC6Pp8hg0HBZjiDHM4MW5XSwVcdO5zEUJgXQOQi5o,3196
 specsmith/templates/governance/verification.md.j2,sha256=imuPhZ1Uh_dqYXsViUSfQ3gMg0KkR8313f67CV_Z734,1665
 specsmith/templates/governance/workflow.md.j2,sha256=Tt3QdPvRFS7F5FZv__8bfU4a_jEYSCRCZSQOsa6fK-A,2358
 specsmith/templates/js/package.json.j2,sha256=_bZLBzRPItYGFGgVTQZ8jG7zXsIlKn0DoSM43oHpwLE,1095
@@ -79,9 +80,9 @@ specsmith/vcs/base.py,sha256=IzyC3xtO8npaNbGZoAzgQyc9iSKleJFnp4GA0otTJfU,4098
 specsmith/vcs/bitbucket.py,sha256=U5cGqpybuPngjpu5GDM8aTZPm9bvZf1099OSBwU_Lro,5014
 specsmith/vcs/github.py,sha256=OVTLs9egmM_Smrxm4-Lo525Pi59x0PDMOOwqNNiM7lA,11995
 specsmith/vcs/gitlab.py,sha256=fDYYoDBic0KBnD_QWYf_K3GmdZOEartLXhzNXf4D4-0,5136
-specsmith-0.2.3.dev51.dist-info/licenses/LICENSE,sha256=jCLkf20ZMVU47ykbfIxw-5eukhnaeIsxSflw07hVNlY,1074
-specsmith-0.2.3.dev51.dist-info/METADATA,sha256=DhyozEDdUdnetivvrvrdJEndv3kCsSayzmE0kYlYylY,6837
-specsmith-0.2.3.dev51.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-specsmith-0.2.3.dev51.dist-info/entry_points.txt,sha256=X_zb8_KvBONFGgkQYKIbW1UtWd3Ck7E11l3SyHO7omA,49
-specsmith-0.2.3.dev51.dist-info/top_level.txt,sha256=UsM7ZABbv3N5s5-tcyJSIE1m_G4p-ezZGK4zgJ3x1Hc,10
-specsmith-0.2.3.dev51.dist-info/RECORD,,
+specsmith-0.2.3.dev55.dist-info/licenses/LICENSE,sha256=jCLkf20ZMVU47ykbfIxw-5eukhnaeIsxSflw07hVNlY,1074
+specsmith-0.2.3.dev55.dist-info/METADATA,sha256=b9od7EuHnV9HSujw9OvyyyJgcn89Zvbmp7aixvFWEMU,8675
+specsmith-0.2.3.dev55.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+specsmith-0.2.3.dev55.dist-info/entry_points.txt,sha256=X_zb8_KvBONFGgkQYKIbW1UtWd3Ck7E11l3SyHO7omA,49
+specsmith-0.2.3.dev55.dist-info/top_level.txt,sha256=UsM7ZABbv3N5s5-tcyJSIE1m_G4p-ezZGK4zgJ3x1Hc,10
+specsmith-0.2.3.dev55.dist-info/RECORD,,