claude-dev-env 2.36.0 → 4.0.0

package/_shared/advisor/scripts/codex_astra_advisor.py

@@ -0,0 +1,308 @@
+"""Bind and consult a read-only Codex CLI session through Astra."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import asdict
+from pathlib import Path
+
+_scripts_directory = Path(__file__).resolve().parent
+_config_directory = _scripts_directory / "config"
+for each_import_directory in (_scripts_directory, _config_directory):
+    each_import_directory_text = str(each_import_directory)
+    if each_import_directory_text not in sys.path:
+        sys.path[:0] = [each_import_directory_text]
+
+from advisor_scripts_constants.astra_advisor_constants import (
+    ADVISOR_CODEX_EXECUTABLE_ENV_VAR,
+    ALL_ASTRA_TRUTHY_VALUES,
+    ASTRA_BIND_FAILURE_REASON,
+    ASTRA_CODEX_TIMEOUT_REASON,
+    ASTRA_CODEX_TIMEOUT_SECONDS,
+    ASTRA_EFFORT_FLAG,
+    ASTRA_ENABLE_FLAG,
+    ASTRA_ENV_VAR,
+    ASTRA_EXECUTABLE_NOT_FOUND_REASON,
+    ASTRA_FALLBACK_KIND_BROKEN,
+    ASTRA_FALLBACK_KIND_DECLINED,
+    ASTRA_SESSION_ID_METAVAR,
+    CLAUDE_CONFIG_DIRECTORY_NAME,
+    CODEX_CONFIG_FLAG,
+    CODEX_EXECUTABLE,
+    CODEX_EXEC_SUBCOMMAND,
+    CODEX_JSON_FLAG,
+    CODEX_MODEL_FLAG,
+    CODEX_PROMPT_FROM_STDIN,
+    CODEX_READ_ONLY_SANDBOX,
+    CODEX_REASONING_CONFIG_TEMPLATE,
+    CODEX_RESUME_SUBCOMMAND,
+    CODEX_SANDBOX_FLAG,
+    USAGE_PROBE_FILENAME,
+    USAGE_PROBE_PACKAGE_DIRECTORY_NAME,
+    USAGE_PROBE_SCRIPTS_DIRECTORY_NAME,
+    USAGE_PROBE_SHARED_DIRECTORY_NAME,
+)
+from advisor_scripts_constants.advisor_route_constants import (
+    ADVISOR_CODEX_MODEL_ID,
+    ADVISOR_EFFORT_DEFAULT,
+    ADVISOR_EFFORT_ENV_VAR,
+    ALL_ADVISOR_EFFORT_LEVELS,
+    SPAWN_OUTCOME_KEY,
+)
+from codex_astra_reply import (
+    CodexAstraAdvisorReply,
+    build_fallback_reply,
+    parse_codex_jsonl_reply,
+)
+from codex_astra_preflight import AstraPreflight, run_astra_preflight
+
+
+def _resolved_settings(
+    all_settings: Mapping[str, str] | None,
+) -> Mapping[str, str]:
+    return os.environ if all_settings is None else all_settings
+
+
+def is_astra_advisor_enabled(all_settings: Mapping[str, str] | None) -> bool:
+    """Return whether the Astra advisor flag is on.
+
+    Args:
+        all_settings: Environment mapping, or None to read os.environ.
+
+    Returns:
+        True when the flag holds a truthy value.
+    """
+    raw_setting = _resolved_settings(all_settings).get(ASTRA_ENV_VAR, "")
+    return raw_setting.strip().lower() in ALL_ASTRA_TRUTHY_VALUES
+
+
+def resolve_advisor_effort(all_settings: Mapping[str, str] | None) -> str:
+    """Return ADVISOR_EFFORT, or low when the value is missing or unknown.
+
+    Args:
+        all_settings: Environment mapping, or None to read os.environ.
+
+    Returns:
+        The requested effort, or low.
+    """
+    requested = _resolved_settings(all_settings).get(ADVISOR_EFFORT_ENV_VAR, "")
+    normalized = requested.strip().lower()
+    return normalized if normalized in ALL_ADVISOR_EFFORT_LEVELS else ADVISOR_EFFORT_DEFAULT
+
+
+def resolve_usage_probe_path(home_directory: Path) -> Path:
+    """Return the Codex usage-probe path under home_directory.
+
+    Args:
+        home_directory: Home directory that holds the installed probe.
+
+    Returns:
+        Path to the usage probe under that home.
+    """
+    return (
+        home_directory
+        / CLAUDE_CONFIG_DIRECTORY_NAME
+        / USAGE_PROBE_SHARED_DIRECTORY_NAME
+        / USAGE_PROBE_PACKAGE_DIRECTORY_NAME
+        / USAGE_PROBE_SCRIPTS_DIRECTORY_NAME
+        / USAGE_PROBE_FILENAME
+    )
+
+
+def resolve_codex_executable(all_settings: Mapping[str, str] | None) -> str | None:
+    """Return the Codex executable from the override or PATH.
+
+    Args:
+        all_settings: Environment mapping, or None to read os.environ.
+
+    Returns:
+        Executable path or name, or None if neither is set.
+    """
+    override = _resolved_settings(all_settings).get(ADVISOR_CODEX_EXECUTABLE_ENV_VAR, "").strip()
+    return override or shutil.which(CODEX_EXECUTABLE)
+
+
+def build_codex_arguments(
+    codex_executable: str,
+    session_id: str | None = None,
+    reasoning_effort: str = ADVISOR_EFFORT_DEFAULT,
+) -> list[str]:
+    """Build the Codex command list for bind or resume.
+
+    Args:
+        codex_executable: Codex executable path or name.
+        session_id: Session to resume, or None for a new bind.
+        reasoning_effort: Codex reasoning effort.
+
+    Returns:
+        Command arguments for Codex exec.
+    """
+    arguments = [
+        codex_executable,
+        CODEX_EXEC_SUBCOMMAND,
+        CODEX_MODEL_FLAG,
+        ADVISOR_CODEX_MODEL_ID,
+        CODEX_CONFIG_FLAG,
+        CODEX_REASONING_CONFIG_TEMPLATE.format(effort=reasoning_effort),
+        CODEX_SANDBOX_FLAG,
+        CODEX_READ_ONLY_SANDBOX,
+        CODEX_JSON_FLAG,
+    ]
+    if session_id is not None:
+        arguments.extend([CODEX_RESUME_SUBCOMMAND, session_id])
+    arguments.append(CODEX_PROMPT_FROM_STDIN)
+    return arguments
+
+
+def _resolve_preflight(
+    preflight: AstraPreflight | None,
+    probe_path: Path | None,
+    process_runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> AstraPreflight:
+    if preflight is not None:
+        return preflight
+    resolved_path = resolve_usage_probe_path(Path.home()) if probe_path is None else probe_path
+    return run_astra_preflight(resolved_path, process_runner)
+
+
+def _run_codex(
+    prompt: str,
+    working_directory: Path,
+    session_id: str | None,
+    all_settings: Mapping[str, str] | None,
+    executable: str,
+    process_runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> subprocess.CompletedProcess[str]:
+    return process_runner(
+        build_codex_arguments(
+            executable,
+            session_id=session_id,
+            reasoning_effort=resolve_advisor_effort(all_settings),
+        ),
+        cwd=str(working_directory),
+        input=prompt,
+        capture_output=True,
+        text=True,
+        check=False,
+        shell=False,
+        timeout=ASTRA_CODEX_TIMEOUT_SECONDS,
+    )
+
+
+def _run_enabled_advisor(
+    prompt: str,
+    working_directory: Path,
+    setting_by_name: Mapping[str, str] | None,
+    session_id: str | None,
+    executable: str,
+    resolved_preflight: AstraPreflight,
+    process_runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> CodexAstraAdvisorReply:
+    if not resolved_preflight.eligible:
+        return build_fallback_reply(resolved_preflight.reason, True, resolved_preflight.fallback_kind)
+    try:
+        completed = _run_codex(
+            prompt, working_directory, session_id, setting_by_name, executable, process_runner
+        )
+    except subprocess.TimeoutExpired as error:
+        return build_fallback_reply(f"{ASTRA_CODEX_TIMEOUT_REASON}: {error}", True)
+    except (OSError, subprocess.SubprocessError) as error:
+        return build_fallback_reply(f"{ASTRA_BIND_FAILURE_REASON}: {error}", True)
+    if completed.returncode != 0:
+        return build_fallback_reply(
+            f"{ASTRA_BIND_FAILURE_REASON}: process exit {completed.returncode}", True
+        )
+    return parse_codex_jsonl_reply(completed.stdout, session_id, True)
+
+
+def run_codex_astra_advisor(
+    prompt: str,
+    working_directory: Path,
+    preflight: AstraPreflight | None,
+    probe_path: Path | None,
+    setting_by_name: Mapping[str, str] | None,
+    session_id: str | None,
+    process_runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> CodexAstraAdvisorReply:
+    """Bind or resume a read-only Codex Astra advisor.
+
+    Args:
+        prompt: Advisor prompt text.
+        working_directory: Working directory for Codex.
+        preflight: Usage probe result, or None to run the probe.
+        probe_path: Usage-probe path, or None for the installed path.
+        setting_by_name: Environment mapping, or None to read os.environ.
+        session_id: Session to resume, or None for a new bind.
+        process_runner: Callable that runs the probe and Codex.
+
+    Returns:
+        Advisor reply, or a fallback.
+    """
+    if not is_astra_advisor_enabled(setting_by_name):
+        return build_fallback_reply("Astra advisor flag is disabled", False, ASTRA_FALLBACK_KIND_DECLINED)
+    executable = resolve_codex_executable(setting_by_name)
+    if executable is None:
+        return build_fallback_reply(ASTRA_EXECUTABLE_NOT_FOUND_REASON, True)
+    resolved_preflight = _resolve_preflight(preflight, probe_path, process_runner)
+    return _run_enabled_advisor(prompt, working_directory, setting_by_name, session_id, executable, resolved_preflight, process_runner)
+
+
+def build_argument_parser() -> argparse.ArgumentParser:
+    """Build the command-line parser for bind and resume.
+
+    Returns:
+        Argument parser for this helper.
+    """
+    parser = argparse.ArgumentParser(description="Bind or consult a read-only Codex Astra advisor.")
+    mode_group = parser.add_mutually_exclusive_group(required=True)
+    mode_group.add_argument("--bind", action="store_true")
+    mode_group.add_argument("--resume", metavar=ASTRA_SESSION_ID_METAVAR)
+    parser.add_argument("--cwd", required=True, type=Path)
+    parser.add_argument(ASTRA_ENABLE_FLAG, dest="is_astra_requested", action="store_true")
+    parser.add_argument(
+        ASTRA_EFFORT_FLAG,
+        dest="astra_effort",
+        choices=ALL_ADVISOR_EFFORT_LEVELS,
+        default=None,
+    )
+    return parser
+
+
+def main(all_cli_arguments: Sequence[str]) -> int:
+    """Run one bind or resume request from stdin.
+
+    Args:
+        all_cli_arguments: CLI arguments after the program name.
+
+    Returns:
+        0 when the advisor reply succeeds, 1 on fallback.
+    """
+    parsed = build_argument_parser().parse_args(list(all_cli_arguments))
+    all_settings = dict(os.environ)
+    if parsed.is_astra_requested:
+        all_settings[ASTRA_ENV_VAR] = "1"
+    if parsed.astra_effort is not None:
+        all_settings[ADVISOR_EFFORT_ENV_VAR] = parsed.astra_effort
+    reply = run_codex_astra_advisor(
+        sys.stdin.read(),
+        parsed.cwd,
+        None,
+        None,
+        all_settings,
+        parsed.resume if not parsed.bind else None,
+        subprocess.run,
+    )
+    payload = asdict(reply)
+    payload[SPAWN_OUTCOME_KEY] = payload.pop("outcome")
+    sys.stdout.write(f"{json.dumps(payload, sort_keys=True)}\n")
+    return 0 if reply.successful else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/_shared/advisor/scripts/codex_astra_preflight.py

@@ -0,0 +1,115 @@
+"""Evaluate Codex usage before an Astra advisor request."""
+
+from __future__ import annotations
+
+import importlib
+import json
+import math
+import subprocess
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+from advisor_scripts_constants.astra_advisor_constants import (
+    ASTRA_FALLBACK_KIND_BROKEN,
+    ASTRA_FALLBACK_KIND_DECLINED,
+    ASTRA_PREFLIGHT_FAILURE_REASON,
+    ASTRA_PROBE_TIMEOUT_REASON,
+    ASTRA_USAGE_PROBE_TIMEOUT_SECONDS,
+)
+
+
+@dataclass(frozen=True)
+class AstraPreflight:
+    eligible: bool
+    percent_left: float | None
+    reason: str
+    fallback_kind: str | None = None
+
+
+def _preflight_fallback(
+    reason: str, percent_left: float | None, fallback_kind: str
+) -> AstraPreflight:
+    return AstraPreflight(False, percent_left, reason, fallback_kind)
+
+
+def _load_usage_gate(probe_path: Path) -> Callable[[float], bool]:
+    probe_directory = str(probe_path.parent)
+    if probe_directory not in sys.path:
+        sys.path.insert(0, probe_directory)
+    return importlib.import_module("codex_usage_probe").is_codex_review_required
+
+
+def _parse_probe_percent(stdout_text: str) -> tuple[float | None, str | None]:
+    try:
+        report = json.loads(stdout_text)
+    except (TypeError, json.JSONDecodeError):
+        return None, "usage report is malformed"
+    if not isinstance(report, dict):
+        return None, "usage report is malformed"
+    raw_percent = report.get("percent_left")
+    if isinstance(raw_percent, bool) or not isinstance(raw_percent, (int, float)):
+        return None, "usage meter is unknown" if raw_percent is None else "usage meter is malformed"
+    percent_left = float(raw_percent)
+    if not math.isfinite(percent_left):
+        return None, "usage meter is malformed"
+    return percent_left, None
+
+
+def _run_probe(
+    probe_path: Path,
+    process_runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> subprocess.CompletedProcess[str]:
+    return process_runner(
+        [sys.executable, str(probe_path)],
+        capture_output=True,
+        text=True,
+        check=False,
+        shell=False,
+        timeout=ASTRA_USAGE_PROBE_TIMEOUT_SECONDS,
+    )
+
+
+def _preflight_from_probe(
+    probe_path: Path, completed: subprocess.CompletedProcess[str]
+) -> AstraPreflight:
+    if completed.returncode != 0:
+        reason = f"{ASTRA_PREFLIGHT_FAILURE_REASON}: probe exit {completed.returncode}"
+        return _preflight_fallback(reason, None, ASTRA_FALLBACK_KIND_BROKEN)
+    percent_left, parse_reason = _parse_probe_percent(completed.stdout)
+    if parse_reason is not None or percent_left is None:
+        reason = f"{ASTRA_PREFLIGHT_FAILURE_REASON}: {parse_reason or 'usage meter is unknown'}"
+        return _preflight_fallback(reason, None, ASTRA_FALLBACK_KIND_BROKEN)
+    if not _load_usage_gate(probe_path)(percent_left):
+        reason = f"{ASTRA_PREFLIGHT_FAILURE_REASON}: usage meter is at or below the gate"
+        return _preflight_fallback(reason, percent_left, ASTRA_FALLBACK_KIND_DECLINED)
+    return AstraPreflight(True, percent_left, "usage meter is above the Astra gate")
+
+
+def run_astra_preflight(
+    probe_path: Path,
+    process_runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> AstraPreflight:
+    """Run the usage probe and decide whether Astra may bind.
+
+    Args:
+        probe_path: Path to the installed usage probe.
+        process_runner: Callable that runs the probe.
+
+    Returns:
+        Eligibility, remaining usage percent, reason, and fallback kind.
+    """
+    try:
+        completed = _run_probe(probe_path, process_runner)
+        return _preflight_from_probe(probe_path, completed)
+    except subprocess.TimeoutExpired as error:
+        return _preflight_fallback(
+            f"{ASTRA_PROBE_TIMEOUT_REASON}: {error}", None, ASTRA_FALLBACK_KIND_BROKEN
+        )
+    except (OSError, subprocess.SubprocessError, ImportError, AttributeError, TypeError, ValueError) as error:
+        return _preflight_fallback(
+            f"{ASTRA_PREFLIGHT_FAILURE_REASON}: {error}",
+            None,
+            ASTRA_FALLBACK_KIND_BROKEN,
+        )

package/_shared/advisor/scripts/codex_astra_reply.py

@@ -0,0 +1,159 @@
+"""Parse Codex JSONL and build Astra advisor replies."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+
+from advisor_scripts_constants.advisor_route_constants import (
+    ADVISOR_FALLBACK_RESULT,
+    ADVISOR_FALLBACK_TIER,
+    ADVISOR_MODEL_TIER,
+    ALL_ADVISOR_GUIDANCE_SIGNALS,
+    CODEX_BIND_SUCCESS_TOKEN,
+)
+from advisor_scripts_constants.astra_advisor_constants import (
+    ASTRA_FALLBACK_KIND_BROKEN,
+    ASTRA_INVALID_SIGNAL_REASON,
+    ASTRA_MALFORMED_JSONL_REASON,
+    ASTRA_MISSING_SESSION_REASON,
+    ASTRA_REPLY_FAILURE_REASON,
+)
+
+
+@dataclass(frozen=True)
+class CodexAstraAdvisorReply:
+    session_id: str | None
+    guidance: str | None
+    successful: bool
+    reason: str | None
+    is_fallback: bool
+    signal: str | None
+    astra_enabled: bool
+    selected_tier: str
+    outcome: str
+    fallback_kind: str | None
+
+
+def build_fallback_reply(
+    reason: str,
+    is_astra_enabled: bool,
+    fallback_kind: str | None = ASTRA_FALLBACK_KIND_BROKEN,
+) -> CodexAstraAdvisorReply:
+    """Build a failed advisor reply.
+
+    Args:
+        reason: Why the request fell back.
+        is_astra_enabled: True when the Astra flag was on.
+        fallback_kind: Kind of fallback.
+
+    Returns:
+        Failed reply with no session or guidance.
+    """
+    return CodexAstraAdvisorReply(
+        None,
+        None,
+        False,
+        reason,
+        True,
+        None,
+        is_astra_enabled,
+        ADVISOR_FALLBACK_TIER,
+        ADVISOR_FALLBACK_RESULT,
+        fallback_kind,
+    )
+
+
+def build_success_reply(
+    session_id: str, guidance: str, signal: str
+) -> CodexAstraAdvisorReply:
+    """Build a successful advisor reply.
+
+    Args:
+        session_id: Codex session id.
+        guidance: Advisor text.
+        signal: First-line guidance signal.
+
+    Returns:
+        Successful reply with Astra enabled.
+    """
+    return CodexAstraAdvisorReply(
+        session_id,
+        guidance,
+        True,
+        None,
+        False,
+        signal,
+        True,
+        ADVISOR_MODEL_TIER,
+        CODEX_BIND_SUCCESS_TOKEN,
+        None,
+    )
+
+
+def _guidance_signal(guidance: str) -> str | None:
+    for each_line in guidance.splitlines():
+        candidate = each_line.strip()
+        if candidate:
+            return candidate if candidate in ALL_ADVISOR_GUIDANCE_SIGNALS else None
+    return None
+
+
+def _parse_event_line(each_line: str) -> tuple[str | None, str | None]:
+    event = json.loads(each_line)
+    if not isinstance(event, dict):
+        raise TypeError("event must be an object")
+    discovered_session_id: str | None = None
+    discovered_guidance: str | None = None
+    if event.get("type") == "thread.started":
+        raw_session = event.get("thread_id")
+        if isinstance(raw_session, str) and raw_session.strip():
+            discovered_session_id = raw_session.strip()
+    completed_event = event.get("item")
+    if event.get("type") == "item.completed" and isinstance(completed_event, dict):
+        message_text = completed_event.get("text")
+        if completed_event.get("type") == "agent_message" and isinstance(message_text, str):
+            discovered_guidance = message_text.strip()
+    return discovered_session_id, discovered_guidance
+
+
+def _collect_reply_parts(jsonl_text: str) -> tuple[str | None, str | None]:
+    session_id: str | None = None
+    guidance: str | None = None
+    for each_line in jsonl_text.splitlines():
+        if each_line.strip():
+            discovered_session_id, discovered_guidance = _parse_event_line(each_line)
+            session_id = discovered_session_id or session_id
+            guidance = discovered_guidance or guidance
+    return session_id, guidance
+
+
+def parse_codex_jsonl_reply(
+    jsonl_text: str,
+    existing_session_id: str | None,
+    is_astra_enabled: bool,
+    fallback_kind: str | None = None,
+) -> CodexAstraAdvisorReply:
+    """Parse Codex JSONL into an Astra advisor reply.
+
+    Args:
+        jsonl_text: JSONL from Codex stdout.
+        existing_session_id: Session expected on resume, or None on bind.
+        is_astra_enabled: True when the Astra flag was on.
+        fallback_kind: Kind of fallback on a failed reply.
+
+    Returns:
+        Advisor reply, or a fallback.
+    """
+    try:
+        session_id, guidance = _collect_reply_parts(jsonl_text)
+    except (TypeError, json.JSONDecodeError):
+        return build_fallback_reply(ASTRA_MALFORMED_JSONL_REASON, is_astra_enabled, fallback_kind)
+    if session_id is None or (existing_session_id is not None and session_id != existing_session_id):
+        return build_fallback_reply(ASTRA_MISSING_SESSION_REASON, is_astra_enabled, fallback_kind)
+    if not guidance:
+        return build_fallback_reply(ASTRA_REPLY_FAILURE_REASON, is_astra_enabled, fallback_kind)
+    signal = _guidance_signal(guidance)
+    if signal is None:
+        return build_fallback_reply(ASTRA_INVALID_SIGNAL_REASON, is_astra_enabled, fallback_kind)
+    return build_success_reply(session_id, guidance, signal)

package/_shared/advisor/scripts/config/advisor_scripts_constants/advisor_route_constants.py

@@ -1,9 +1,9 @@
-"""Shared advisor_route_constants for advisor selection and replies."""
+"""Shared constants for advisor selection and replies."""
 
 from __future__ import annotations
 
-ADVISOR_MODEL_TIER: str = "Sol"
-ADVISOR_CODEX_MODEL_ID: str = "gpt-5.6-sol"
+ADVISOR_MODEL_TIER: str = "Astra"
+ADVISOR_CODEX_MODEL_ID: str = "gpt-6-astra"
 ADVISOR_FALLBACK_TIER: str = "Fable"
 ADVISOR_FALLBACK_RESULT: str = "fable"
 ADVISOR_EFFORT_ENV_VAR: str = "ADVISOR_EFFORT"

package/_shared/advisor/scripts/config/advisor_scripts_constants/astra_advisor_constants.py

@@ -0,0 +1,38 @@
+"""Constants for the optional Codex Astra advisor bind."""
+
+from __future__ import annotations
+
+CODEX_EXECUTABLE: str = "codex"
+ADVISOR_CODEX_EXECUTABLE_ENV_VAR: str = "ADVISOR_CODEX_EXECUTABLE"
+CODEX_READ_ONLY_SANDBOX: str = "read-only"
+CODEX_JSON_FLAG: str = "--json"
+CODEX_MODEL_FLAG: str = "--model"
+CODEX_CONFIG_FLAG: str = "--config"
+CODEX_REASONING_CONFIG_TEMPLATE: str = 'model_reasoning_effort="{effort}"'
+CODEX_PROMPT_FROM_STDIN: str = "-"
+CODEX_EXEC_SUBCOMMAND: str = "exec"
+CODEX_RESUME_SUBCOMMAND: str = "resume"
+CODEX_SANDBOX_FLAG: str = "--sandbox"
+CLAUDE_CONFIG_DIRECTORY_NAME: str = ".claude"
+USAGE_PROBE_SHARED_DIRECTORY_NAME: str = "_shared"
+USAGE_PROBE_PACKAGE_DIRECTORY_NAME: str = "pr-loop"
+USAGE_PROBE_SCRIPTS_DIRECTORY_NAME: str = "scripts"
+USAGE_PROBE_FILENAME: str = "codex_usage_probe.py"
+ASTRA_SESSION_ID_METAVAR: str = "SESSION_ID"
+ASTRA_CODEX_TIMEOUT_SECONDS: float = 120.0
+ASTRA_USAGE_PROBE_TIMEOUT_SECONDS: float = 30.0
+ASTRA_ENV_VAR: str = "ADVISOR_ASTRA"
+ALL_ASTRA_TRUTHY_VALUES: frozenset[str] = frozenset({"1", "true", "yes", "on"})
+ASTRA_PREFLIGHT_FAILURE_REASON: str = "astra preflight did not establish an eligible Codex meter"
+ASTRA_BIND_FAILURE_REASON: str = "Codex Astra bind failed"
+ASTRA_REPLY_FAILURE_REASON: str = "Codex Astra returned no advisor guidance"
+ASTRA_PROBE_TIMEOUT_REASON: str = "Codex Astra meter check timed out"
+ASTRA_CODEX_TIMEOUT_REASON: str = "Codex Astra request timed out"
+ASTRA_MALFORMED_JSONL_REASON: str = "Codex Astra returned malformed JSONL"
+ASTRA_MISSING_SESSION_REASON: str = "Codex Astra returned no session id"
+ASTRA_INVALID_SIGNAL_REASON: str = "Codex Astra returned an invalid guidance signal"
+ASTRA_EXECUTABLE_NOT_FOUND_REASON: str = "Codex Astra could not find the codex executable on PATH"
+ASTRA_FALLBACK_KIND_DECLINED: str = "declined"
+ASTRA_FALLBACK_KIND_BROKEN: str = "broken"
+ASTRA_ENABLE_FLAG: str = "--enable-astra"
+ASTRA_EFFORT_FLAG: str = "--effort"