@julioborges/gantry 1.0.5 → 1.1.0

package/.agents/skills/gantry/scripts/discovery.py

@@ -116,6 +116,122 @@ def discover_antigravity_models(runner: Callable[..., subprocess.CompletedProces
     return models
 
 
+_DISCOVERY_CACHE: dict[str, list[dict[str, Any]]] = {}
+
+
+def clear_discovery_cache() -> None:
+    """Clear in-memory discovery cache."""
+    _DISCOVERY_CACHE.clear()
+
+
+def parse_codex_models_output(
+    raw_output: str,
+    metadata_lookup: dict[str, Any] | None = None,
+) -> list[dict[str, Any]]:
+    """Parse stdout from `codex models` into a structured list of model dicts without inventing windows."""
+    cleaned = clean_ansi(raw_output)
+    models: list[dict[str, Any]] = []
+    seen: set[str] = set()
+
+    for line in cleaned.splitlines():
+        line = line.strip()
+        if not line or line.startswith("Fetching") or line.startswith("Usage:") or line.startswith("Models:"):
+            continue
+        parts = line.split(None, 1)
+        if not parts:
+            continue
+        model_id = parts[0].strip().strip("-*• ")
+        if not model_id:
+            continue
+        display_name = parts[1].strip() if len(parts) > 1 else model_id
+
+        if model_id in seen:
+            continue
+        seen.add(model_id)
+
+        entry: dict[str, Any] = {
+            "id": model_id,
+            "name": display_name,
+        }
+
+        if metadata_lookup and model_id in metadata_lookup:
+            meta = metadata_lookup[model_id]
+            if isinstance(meta, dict):
+                if "contextWindow" in meta:
+                    entry["contextWindow"] = meta["contextWindow"]
+                if "supportedEfforts" in meta:
+                    entry["supportedEfforts"] = meta["supportedEfforts"]
+                if "effort" in meta:
+                    entry["effort"] = meta["effort"]
+
+        models.append(entry)
+
+    return models
+
+
+def get_codex_version(runner: Callable[..., Any] | None = None) -> str:
+    """Extract version from `codex --version`."""
+    codex_path = shutil.which("codex")
+    if not codex_path and runner is None:
+        raise DiscoveryError("Missing discovery: codex CLI not found in PATH")
+
+    run_cmd = runner or subprocess.run
+    try:
+        proc = run_cmd([codex_path or "codex", "--version"], capture_output=True, text=True, check=False)
+    except OSError as exc:
+        raise DiscoveryError(f"Missing discovery: failed to run codex --version: {exc}") from exc
+
+    if proc.returncode != 0:
+        err = proc.stderr.strip() or proc.stdout.strip()
+        raise DiscoveryError(f"Missing discovery: codex --version returned exit code {proc.returncode}: {err}")
+
+    cleaned = clean_ansi(proc.stdout or proc.stderr).strip()
+    match = re.search(r"(\d+\.\d+(?:\.\d+)?)", cleaned)
+    if not match:
+        raise DiscoveryError(f"Missing discovery: could not parse codex version from {cleaned!r}")
+    return match.group(1)
+
+
+def discover_codex_models(
+    runner: Callable[..., Any] | None = None,
+    use_cache: bool = True,
+) -> list[dict[str, Any]]:
+    """Discover executable models via `codex models` with metadata lookup and caching."""
+    if use_cache and "codex" in _DISCOVERY_CACHE and runner is None:
+        return list(_DISCOVERY_CACHE["codex"])
+
+    codex_path = shutil.which("codex")
+    if not codex_path and runner is None:
+        raise DiscoveryError("Missing discovery: codex CLI not found in PATH")
+
+    run_cmd = runner or subprocess.run
+    try:
+        proc = run_cmd([codex_path or "codex", "models"], capture_output=True, text=True, check=False)
+    except OSError as exc:
+        raise DiscoveryError(f"Missing discovery: failed to run codex models: {exc}") from exc
+
+    if proc.returncode != 0:
+        err = proc.stderr.strip() or proc.stdout.strip()
+        raise DiscoveryError(f"Missing discovery: codex models returned exit code {proc.returncode}: {err}")
+
+    cap_file = Path(__file__).resolve().parents[1] / "capabilities" / "codex.json"
+    metadata_lookup = {}
+    if cap_file.exists():
+        try:
+            metadata_lookup = json.loads(cap_file.read_text(encoding="utf-8")).get("models", {})
+        except Exception:
+            pass
+
+    models = parse_codex_models_output(proc.stdout, metadata_lookup=metadata_lookup)
+    if not models:
+        raise DiscoveryError("Missing discovery: codex models returned an empty model list")
+
+    if use_cache and runner is None:
+        _DISCOVERY_CACHE["codex"] = models
+
+    return models
+
+
 def discover_models(harness: str, runner: Callable[..., Any] | None = None) -> list[dict[str, Any]]:
     """Discover executable models for the given harness; fail closed on missing discovery."""
     h = (harness or "").lower()
@@ -143,14 +259,7 @@ def discover_models(harness: str, runner: Callable[..., Any] | None = None) -> l
             return [{"id": m, "contextWindow": d["contextWindow"]} for m, d in cap.get("models", {}).items()]
         raise DiscoveryError("Missing discovery: opencode capability declaration missing")
     elif h == "codex":
-        codex_path = shutil.which("codex")
-        if not codex_path:
-            raise DiscoveryError("Missing discovery: codex CLI not found in PATH")
-        cap_file = Path(__file__).resolve().parents[1] / "capabilities" / "codex.json"
-        if cap_file.exists():
-            cap = json.loads(cap_file.read_text(encoding="utf-8"))
-            return [{"id": m, "contextWindow": d["contextWindow"]} for m, d in cap.get("models", {}).items()]
-        raise DiscoveryError("Missing discovery: codex capability declaration missing")
+        return discover_codex_models(runner=runner)
 
     raise DiscoveryError(f"Missing discovery: unhandled harness {harness}")
 

package/.agents/skills/gantry/scripts/execution.py

@@ -63,6 +63,10 @@ class ProtocolFailureError(Exception):
     """Raised when an external role result is missing, undecodable or fails the schema contract."""
 
 
+class ExecutionFailureError(RuntimeError):
+    """Raised when an external harness command fails at runtime (crash, timeout, non-zero exit)."""
+
+
 def parse_semver(version_str: str) -> tuple[int, int, int]:
     match = re.search(r"(\d+)\.(\d+)(?:\.(\d+))?", version_str)
     if not match:
@@ -73,11 +77,67 @@ def parse_semver(version_str: str) -> tuple[int, int, int]:
     return (major, minor, patch)
 
 
+def validate_codex_auth(runner: Callable[..., Any] | None = None) -> dict[str, Any]:
+    """Validate Codex authentication via `codex login status`."""
+    cli_name = CLI_NAMES.get("codex", "codex")
+    if runner is None and not shutil.which(cli_name):
+        return {
+            "valid": False,
+            "error": f"Codex CLI binary '{cli_name}' not found on PATH. Please install Codex CLI or ensure it is in your PATH.",
+        }
+
+    run_cmd = runner or subprocess.run
+    try:
+        try:
+            proc = run_cmd([cli_name, "login", "status"], capture_output=True, text=True, check=False)
+        except TypeError:
+            proc = run_cmd([cli_name, "login", "status"])
+    except FileNotFoundError:
+        return {
+            "valid": False,
+            "error": f"Codex CLI binary '{cli_name}' not found on PATH. Please install Codex CLI or ensure it is in your PATH.",
+        }
+    except Exception as exc:
+        return {
+            "valid": False,
+            "error": f"Codex CLI authentication check failed: {exc}. Run 'codex login' to authenticate.",
+        }
+
+    if proc.returncode != 0:
+        err = (getattr(proc, "stderr", "") or "").strip() or (getattr(proc, "stdout", "") or "").strip()
+        return {
+            "valid": False,
+            "error": f"Codex CLI is unauthenticated ({err or f'exit code {proc.returncode}'}). Run 'codex login' to authenticate.",
+        }
+
+    stdout = (getattr(proc, "stdout", "") or "").strip().lower()
+    if "not logged in" in stdout or "unauthenticated" in stdout or "no credentials" in stdout:
+        return {
+            "valid": False,
+            "error": f"Codex CLI is unauthenticated ({proc.stdout.strip()}). Run 'codex login' to authenticate.",
+        }
+
+    return {"valid": True}
+
+
 def validate_harness_version(
     harness: str,
     runner: Callable[..., Any] | None = None,
 ) -> dict[str, Any]:
     cli_name = CLI_NAMES.get(harness, harness)
+    if runner is None and not shutil.which(cli_name):
+        if harness == "codex":
+            return {
+                "valid": False,
+                "version": None,
+                "error": f"Codex CLI binary '{cli_name}' not found on PATH. Please install Codex CLI or ensure it is in your PATH.",
+            }
+        return {
+            "valid": False,
+            "version": None,
+            "error": f"Harness CLI '{cli_name}' not found on PATH",
+        }
+
     try:
         if runner:
             try:
@@ -87,6 +147,12 @@ def validate_harness_version(
         else:
             proc = subprocess.run([cli_name, "--version"], capture_output=True, text=True, check=False)
         if proc.returncode != 0:
+            if harness == "codex":
+                return {
+                    "valid": False,
+                    "version": None,
+                    "error": f"Harness CLI {cli_name} authentication/execution validation failed: return code {proc.returncode}. Run 'codex login' to authenticate.",
+                }
             return {
                 "valid": False,
                 "version": None,
@@ -105,6 +171,18 @@ def validate_harness_version(
             }
         ver_formatted = f"{version_tuple[0]}.{version_tuple[1]}.{version_tuple[2]}"
         return {"valid": True, "version": ver_formatted}
+    except FileNotFoundError:
+        if harness == "codex":
+            return {
+                "valid": False,
+                "version": None,
+                "error": f"Codex CLI binary '{cli_name}' not found on PATH. Please install Codex CLI or ensure it is in your PATH.",
+            }
+        return {
+            "valid": False,
+            "version": None,
+            "error": f"Harness CLI '{cli_name}' not found on PATH",
+        }
     except Exception as exc:
         return {
             "valid": False,
@@ -320,6 +398,14 @@ def validate_selection(
                 "role": role,
                 "error": ver_check["error"],
             }
+        if harness == "codex":
+            auth_check = validate_codex_auth(runner=runner)
+            if not auth_check["valid"]:
+                return {
+                    "valid": False,
+                    "role": role,
+                    "error": auth_check["error"],
+                }
 
     return {"valid": True, "role": role}
 
@@ -344,7 +430,10 @@ def build_dispatch_command(
     elif h == "opencode":
         return ["opencode", "run", prompt, "--model", model]
     elif h == "codex":
-        return ["codex", "exec", prompt, "--model", model]
+        cmd = ["codex", "exec", prompt, "--model", model]
+        if effort:
+            cmd.extend(["--effort", effort])
+        return cmd
     else:
         raise ValueError(f"Unsupported harness: {harness}")
 
@@ -387,15 +476,9 @@ def parse_and_validate_result(
     if not raw_output or not raw_output.strip():
         raise ProtocolFailureError(f"Protocol failure: empty output returned for role {role}")
 
-    text = raw_output.strip()
-    if text.startswith("```json") and text.endswith("```"):
-        text = text[7:-3].strip()
-    elif text.startswith("```") and text.endswith("```"):
-        text = text[3:-3].strip()
-
     try:
-        data = json.loads(text)
-    except json.JSONDecodeError as exc:
+        data = result.extract_json(raw_output)
+    except (json.JSONDecodeError, ValueError) as exc:
         raise ProtocolFailureError(f"Protocol failure: invalid JSON output for role {role}: {exc}") from exc
 
     if not isinstance(data, dict):
@@ -456,6 +539,7 @@ def dispatch_role(
     unit_id: str | None = None,
     state_root: str | None = None,
     retry_on_invalid: bool = True,
+    timeout: int | float | None = None,
 ) -> dict[str, Any]:
     """Execute a bounded role invocation in the selected native harness."""
     cwd_path = Path(cwd).resolve()
@@ -481,6 +565,10 @@ def dispatch_role(
     if not eff_val["valid"]:
         raise ValueError(eff_val["error"])
 
+    eff_timeout = timeout
+    if eff_timeout is None and isinstance(policy, dict):
+        eff_timeout = policy.get("execution", {}).get("timeout")
+
     if run_id and unit_id:
         try:
             root = runlog.state_root(state_root)
@@ -508,10 +596,25 @@ def dispatch_role(
 
     cmd = build_dispatch_command(harness, model, prompt, effort=effort)
     run_fn = runner or subprocess.run
-    proc = run_fn(cmd, cwd=str(cwd_path), capture_output=True, text=True, check=False)
+    run_kwargs: dict[str, Any] = {"cwd": str(cwd_path), "capture_output": True, "text": True, "check": False}
+    if eff_timeout is not None:
+        run_kwargs["timeout"] = eff_timeout
+
+    try:
+        try:
+            proc = run_fn(cmd, **run_kwargs)
+        except TypeError:
+            proc = run_fn(cmd, cwd=str(cwd_path))
+    except subprocess.TimeoutExpired as exc:
+        raise ExecutionFailureError(f"Harness {harness} execution timed out after {eff_timeout}s: {exc}") from exc
+    except Exception as exc:
+        if isinstance(exc, (ExecutionFailureError, UnsupportedHarnessVersionError, ModelFallbackError, ProtocolFailureError)):
+            raise
+        raise ExecutionFailureError(f"Harness {harness} execution failed to start or crashed: {exc}") from exc
+
     if proc.returncode != 0:
-        err = (proc.stderr or "").strip() or (proc.stdout or "").strip()
-        raise RuntimeError(f"Harness {harness} execution failed (exit {proc.returncode}): {err}")
+        err = (getattr(proc, "stderr", "") or "").strip() or (getattr(proc, "stdout", "") or "").strip()
+        raise ExecutionFailureError(f"Harness {harness} execution failed (exit {proc.returncode}): {err}")
 
     check_model_fallback(model, proc.stdout)
 
@@ -523,9 +626,21 @@ def dispatch_role(
         if retry_on_invalid:
             retry_prompt = f"{prompt}\n\nYour prior result was invalid: {exc}\nReturn the complete {role} result contract."
             retry_cmd = build_dispatch_command(harness, model, retry_prompt, effort=effort)
-            proc2 = run_fn(retry_cmd, cwd=str(cwd_path), capture_output=True, text=True, check=False)
+            try:
+                try:
+                    proc2 = run_fn(retry_cmd, **run_kwargs)
+                except TypeError:
+                    proc2 = run_fn(retry_cmd, cwd=str(cwd_path))
+            except subprocess.TimeoutExpired as exc2:
+                raise ExecutionFailureError(f"Harness {harness} retry execution timed out after {eff_timeout}s: {exc2}") from exc2
+            except Exception as exc2:
+                if isinstance(exc2, (ExecutionFailureError, UnsupportedHarnessVersionError, ModelFallbackError, ProtocolFailureError)):
+                    raise
+                raise ExecutionFailureError(f"Harness {harness} retry failed to start or crashed: {exc2}") from exc2
+
             if proc2.returncode != 0:
-                raise RuntimeError(f"Harness {harness} retry failed (exit {proc2.returncode}): {(proc2.stderr or '').strip()}")
+                err2 = (getattr(proc2, "stderr", "") or "").strip() or (getattr(proc2, "stdout", "") or "").strip()
+                raise ExecutionFailureError(f"Harness {harness} retry failed (exit {proc2.returncode}): {err2}")
             check_model_fallback(model, proc2.stdout)
             data = parse_and_validate_result(role, proc2.stdout)
             if role in ("critic", "requirement-critic", "plan-critic"):
@@ -685,6 +800,7 @@ def main() -> int:
     dispatch_parser.add_argument("--run-id", help="Run ID for logging")
     dispatch_parser.add_argument("--unit-id", help="Unit ID for logging")
     dispatch_parser.add_argument("--state-root", help="State root directory")
+    dispatch_parser.add_argument("--timeout", type=float, help="execution timeout in seconds")
     dispatch_parser.add_argument("--json", action="store_true", help="output JSON")
 
     failures_parser = subparsers.add_parser("unresolved-failures", help="check for unresolved paused executions")
@@ -750,6 +866,7 @@ def main() -> int:
                 run_id=getattr(args, "run_id", None),
                 unit_id=getattr(args, "unit_id", None),
                 state_root=getattr(args, "state_root", None),
+                timeout=getattr(args, "timeout", None),
             )
             print(json.dumps(res, indent=2))
             return 0

package/.agents/skills/gantry/scripts/guard.py

@@ -569,8 +569,14 @@ def main() -> int:
 
     payload = read_payload()
     cwd = Path(args.cwd).resolve()
+    name = tool_name(payload) if payload else ""
+    normalized_name = re.sub(r"[^a-z]", "", name)
 
     def allow() -> int:
+        if args.event == "PostToolUse" and (not args.run_id or normalized_name != "invokesubagent"):
+            if args.json:
+                print("{}")
+            return 0
         if args.json:
             print(json.dumps({"decision": "allow"}, separators=(",", ":")))
         else: