agroute 0.1.0__py3-none-any.whl

agroute/__init__.py

@@ -0,0 +1,9 @@
+"""Configurable local agent router with native usage-limit filtering and howhard integration."""
+
+__version__ = "0.1.0"
+
+from .config import load_config
+from .router import Router
+from .validation import AgRouteError
+
+__all__ = ["AgRouteError", "Router", "load_config", "__version__"]

agroute/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

agroute/cli.py

@@ -0,0 +1,249 @@
+"""Command-line interface for agroute."""
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from . import __version__
+from .files import atomic_write
+from .router import Router
+from .validation import AgRouteError
+
+
+def _add_common_flags(parser):
+    parser.add_argument("--config", default=None, help="Path to agroute.toml configuration file")
+    parser.add_argument("--state-dir", default=None, help="Explicit state directory override")
+    parser.add_argument(
+        "--no-user-config",
+        action="store_true",
+        help="Ignore user-level ~/.config/agroute/config.toml",
+    )
+    parser.add_argument("--now", default=None, help="Evaluation timestamp override (ISO-8601 UTC)")
+    parser.add_argument("--json", action="store_true", help="Emit structured JSON output")
+
+
+def _build_parser():
+    parser = argparse.ArgumentParser(
+        prog="agroute",
+        description="Configurable local agent router across Codex, Claude Code, and Antigravity.",
+    )
+    parser.add_argument("--version", action="version", version=f"agroute {__version__}")
+    _add_common_flags(parser)
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    # paths
+    p_paths = subparsers.add_parser("paths", help="Show resolved capture and state roots")
+    _add_common_flags(p_paths)
+
+    # usage
+    p_usage = subparsers.add_parser("usage", help="Inspect or update native agent quota and rate-limit state")
+    _add_common_flags(p_usage)
+    usage_sub = p_usage.add_subparsers(dest="usage_command")
+
+    p_u_show = usage_sub.add_parser("show", help="Show effective quota and eligibility per agent")
+    p_u_show.add_argument("--agent", default=None, help="Filter to a single agent (codex|claude|agy)")
+    _add_common_flags(p_u_show)
+
+    p_u_set = usage_sub.add_parser("set", help="Explicitly set quota window percentages or cooldowns")
+    p_u_set.add_argument("--agent", required=True, help="Target agent (codex|claude|agy)")
+    p_u_set.add_argument("--session-used-pct", type=float, default=None, help="5h session used percentage (0-100)")
+    p_u_set.add_argument("--session-reset-at", default=None, help="5h session reset timestamp (ISO-8601 or epoch)")
+    p_u_set.add_argument("--weekly-used-pct", type=float, default=None, help="7d weekly used percentage (0-100)")
+    p_u_set.add_argument("--weekly-reset-at", default=None, help="7d weekly reset timestamp (ISO-8601 or epoch)")
+    p_u_set.add_argument("--tier", default=None, help="Model tier name (e.g. opus, sonnet, pro, flash)")
+    p_u_set.add_argument("--tier-used-pct", type=float, default=None, help="Tier used percentage (0-100)")
+    p_u_set.add_argument("--tier-reset-at", default=None, help="Tier reset timestamp (ISO-8601 or epoch)")
+    rl_group = p_u_set.add_mutually_exclusive_group()
+    rl_group.add_argument("--rate-limited", dest="rate_limited", action="store_true", default=None)
+    rl_group.add_argument("--no-rate-limited", dest="rate_limited", action="store_false")
+    p_u_set.add_argument("--cooldown-until", default=None, help="Rate-limit cooldown expiry timestamp")
+    _add_common_flags(p_u_set)
+
+    p_u_ingest = usage_sub.add_parser("ingest", help="Parse native usage/status output for an agent")
+    p_u_ingest.add_argument("--agent", required=True, help="Target agent (codex|claude|agy)")
+    p_u_ingest.add_argument("--file", default=None, help="Path to captured native status/event output")
+    p_u_ingest.add_argument("--text", default=None, help="Inline native status/event text")
+    _add_common_flags(p_u_ingest)
+
+    p_u_probe = usage_sub.add_parser("probe", help="Run configured read-only usage_probe_cmd")
+    p_u_probe.add_argument("--agent", default=None, help="Target agent (codex|claude|agy)")
+    _add_common_flags(p_u_probe)
+
+    p_u_clear = usage_sub.add_parser("clear", help="Clear stored quota state for an agent or all agents")
+    p_u_clear.add_argument("--agent", default=None, help="Target agent (codex|claude|agy)")
+    _add_common_flags(p_u_clear)
+
+    # candidates
+    p_cands = subparsers.add_parser("candidates", help="Emit filtered howhard-compatible candidates")
+    p_cands.add_argument("--host", default=None, help="Current host agent (codex|claude|agy)")
+    p_cands.add_argument("--include-agents", default=None, help="Comma-separated subset of agents to consider")
+    p_cands.add_argument("--output", default=None, help="Write the howhard candidate JSON array to this file")
+    _add_common_flags(p_cands)
+
+    # inventory
+    p_inv = subparsers.add_parser("inventory", help="Emit howhard.toml [inventories] block for howhard 2.1+")
+    p_inv.add_argument("--host", default=None, help="Current host agent (codex|claude|agy)")
+    p_inv.add_argument("--name", default="router", help="Inventory name in howhard.toml (default: router)")
+    p_inv.add_argument("--include-agents", default=None, help="Comma-separated subset of agents to consider")
+    p_inv.add_argument("--format", choices=("toml", "json"), default="toml", help="Output format")
+    p_inv.add_argument("--output", default=None, help="Write inventory output to this file")
+    _add_common_flags(p_inv)
+
+    # plan
+    p_plan = subparsers.add_parser(
+        "plan", help="Resolve a howhard decision JSON into a native or CLI execution plan"
+    )
+    p_plan.add_argument("--host", default=None, help="Current host agent (codex|claude|agy)")
+    p_plan.add_argument("--decision", required=True, help="Path to howhard decision JSON file")
+    p_plan.add_argument("--prompt", default=None, help="Authorized task prompt text")
+    p_plan.add_argument("--prompt-file", default=None, help="File containing authorized task prompt text")
+    p_plan.add_argument("--role", default="Task Worker", help="Worker role/description for native subagents")
+    p_plan.add_argument("--subagent-type", default=None, help="Host-specific subagent type override")
+    p_plan.add_argument("--workspace", default="inherit", help="Antigravity subagent workspace mode")
+    p_plan.add_argument("--include-agents", default=None, help="Comma-separated subset of agents to consider")
+    p_plan.add_argument("--output", default=None, help="Write resolved execution plan JSON to this file")
+    _add_common_flags(p_plan)
+
+    return parser
+
+
+def _parse_include_agents(raw):
+    if not raw:
+        return None
+    return [part.strip() for part in raw.split(",") if part.strip()]
+
+
+def _emit(payload, *, as_json=True):
+    if isinstance(payload, str) and not as_json:
+        sys.stdout.write(payload if payload.endswith("\n") else payload + "\n")
+    else:
+        sys.stdout.write(json.dumps(payload, indent=2, sort_keys=False) + "\n")
+
+
+def main(argv=None):
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if not args.command:
+        parser.print_help(sys.stderr)
+        return 2
+
+    try:
+        router = Router(
+            args.config,
+            state_directory=args.state_dir,
+            include_user_config=not args.no_user_config,
+        )
+
+        if args.command == "paths":
+            _emit(router.paths(), as_json=True)
+            return 0
+
+        if args.command == "usage":
+            sub = args.usage_command or "show"
+            if sub == "show":
+                _emit(router.usage_show(getattr(args, "agent", None), now=args.now), as_json=True)
+                return 0
+            if sub == "set":
+                res = router.usage_set(
+                    args.agent,
+                    session_used_pct=args.session_used_pct,
+                    session_reset_at=args.session_reset_at,
+                    weekly_used_pct=args.weekly_used_pct,
+                    weekly_reset_at=args.weekly_reset_at,
+                    rate_limited=args.rate_limited,
+                    cooldown_until=args.cooldown_until,
+                    tier=args.tier,
+                    tier_used_pct=args.tier_used_pct,
+                    tier_reset_at=args.tier_reset_at,
+                    now=args.now,
+                )
+                _emit(res, as_json=True)
+                return 0
+            if sub == "ingest":
+                if args.file and args.text:
+                    raise AgRouteError("usage ingest: specify either --file or --text, not both")
+                if args.file:
+                    try:
+                        raw_text = Path(args.file).read_text(encoding="utf-8")
+                    except OSError as exc:
+                        raise AgRouteError(f"usage ingest: unable to read {args.file}: {exc}") from exc
+                elif args.text is not None:
+                    raw_text = args.text
+                else:
+                    raw_text = sys.stdin.read()
+                res = router.usage_ingest(args.agent, raw_text, now=args.now)
+                _emit(res, as_json=True)
+                return 0
+            if sub == "probe":
+                res = router.usage_probe(args.agent, now=args.now)
+                _emit(res, as_json=True)
+                return 0
+            if sub == "clear":
+                res = router.usage_clear(args.agent)
+                _emit(res, as_json=True)
+                return 0
+
+        if args.command == "candidates":
+            include = _parse_include_agents(args.include_agents)
+            res = router.candidates(args.host, include_agents=include, now=args.now)
+            if args.output:
+                atomic_write(args.output, json.dumps(res["candidates"], indent=2) + "\n")
+            _emit(res, as_json=True)
+            return 0
+
+        if args.command == "inventory":
+            include = _parse_include_agents(args.include_agents)
+            if args.format == "toml" and not args.json:
+                rendered = router.format_inventory_toml(
+                    args.host, name=args.name, include_agents=include, now=args.now
+                )
+                if args.output:
+                    atomic_write(args.output, rendered)
+                _emit(rendered, as_json=False)
+            else:
+                res = router.inventory(
+                    args.host, name=args.name, include_agents=include, now=args.now
+                )
+                if args.output:
+                    atomic_write(args.output, json.dumps(res, indent=2) + "\n")
+                _emit(res, as_json=True)
+            return 0
+
+        if args.command == "plan":
+            if args.prompt is not None and args.prompt_file is not None:
+                raise AgRouteError("plan: specify either --prompt or --prompt-file, not both")
+            prompt = args.prompt
+            if args.prompt_file is not None:
+                try:
+                    prompt = Path(args.prompt_file).read_text(encoding="utf-8")
+                except OSError as exc:
+                    raise AgRouteError(f"plan: unable to read {args.prompt_file}: {exc}") from exc
+            try:
+                decision_obj = json.loads(Path(args.decision).read_text(encoding="utf-8"))
+            except (OSError, ValueError, UnicodeError) as exc:
+                raise AgRouteError(f"plan: invalid decision JSON file {args.decision}: {exc}") from exc
+            include = _parse_include_agents(args.include_agents)
+            plan_obj = router.plan(
+                args.host,
+                decision_obj,
+                prompt=prompt,
+                role=args.role,
+                subagent_type=args.subagent_type,
+                workspace=args.workspace,
+                include_agents=include,
+                now=args.now,
+            )
+            if args.output:
+                atomic_write(args.output, json.dumps(plan_obj, indent=2) + "\n")
+            _emit(plan_obj, as_json=True)
+            return 0
+
+    except AgRouteError as exc:
+        print(f"agroute: error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

agroute/config.py

@@ -0,0 +1,272 @@
+"""Layered configuration loading and strict validation."""
+
+from copy import deepcopy
+from dataclasses import dataclass
+from importlib.resources import files
+import os
+from pathlib import Path
+import tomllib
+
+from .state import roots
+from .validation import (
+    AGENTS,
+    AgRouteError,
+    agent_id,
+    boolean,
+    effort_id,
+    keys,
+    number,
+     parse_timestamp,
+    percentage,
+    table,
+    text,
+)
+
+RATE_CATEGORIES = ("input", "output", "cache_read", "cache_write", "cache_write_5m", "cache_write_1h")
+
+
+@dataclass
+class Config:
+    capture_root: Path
+    state_root: Path
+    identity_path: Path
+    project_identity: str
+    config_path: Path | None
+    user_config_path: Path | None
+    default_host: str
+    host_affinity_epsilon: float
+    namespace_separator: str
+    agents: dict
+
+
+def _validate_rate_card(card, where):
+    keys(
+        card,
+        ["format", "source", "version", "effective_at", "provider", "model", "service_tier", "basis", "rates"],
+        where=where,
+    )
+    if card["format"] != "howhard-rate-card-v1" or card["basis"] not in ("estimate", "charge"):
+        raise AgRouteError(f"{where}: unsupported format or basis")
+    for key in ("source", "version", "provider", "model"):
+        text(card[key], f"{where}.{key}")
+    if card["service_tier"] is not None:
+        text(card["service_tier"], f"{where}.service_tier")
+    parse_timestamp(card["effective_at"], f"{where}.effective_at")
+    rates = table(card["rates"], f"{where}.rates")
+    keys(rates, RATE_CATEGORIES, where=f"{where}.rates")
+    for category, amount in rates.items():
+        if amount is not None:
+            number(amount, f"{where}.rates.{category}", nonnegative=True)
+    return deepcopy(card)
+
+
+def _validate_candidate_list(items, where, *, agent):
+    if not isinstance(items, list):
+        raise AgRouteError(f"{where}: expected a list of candidate tables")
+    seen = set()
+    validated = []
+    for index, raw in enumerate(items):
+        entry_where = f"{where}[{index}]"
+        keys(
+            raw,
+            ["model", "effort"],
+            ["tier", "usd_per_mtok", "rate_card"],
+            where=entry_where,
+        )
+        model = text(raw["model"], f"{entry_where}.model", max_length=200)
+        if "/" in model or ":" in model:
+            raise AgRouteError(
+                f"{entry_where}.model: configure bare native model ID '{model}' without agent prefix"
+            )
+        effort = effort_id(raw["effort"], f"{entry_where}.effort")
+        if agent == "agy" and where.endswith("native_candidates") and model not in (
+            "inherit",
+            "flash_lite",
+            "flash",
+            "pro",
+        ):
+            raise AgRouteError(
+                f"{entry_where}.model: Antigravity native subagent model must be one of inherit, flash_lite, flash, pro"
+            )
+        pair = (model, effort)
+        if pair in seen:
+            raise AgRouteError(f"{entry_where}: duplicate candidate cell ({model!r}, {effort!r})")
+        seen.add(pair)
+        if "usd_per_mtok" in raw and "rate_card" in raw and raw["usd_per_mtok"] is not None and raw["rate_card"] is not None:
+            raise AgRouteError(f"{entry_where}: candidate cannot specify both usd_per_mtok and rate_card")
+        cell = {"model": model, "effort": effort}
+        if raw.get("tier") is not None:
+            cell["tier"] = text(raw["tier"], f"{entry_where}.tier", label=True, max_length=64)
+        if raw.get("usd_per_mtok") is not None:
+            cell["usd_per_mtok"] = number(raw["usd_per_mtok"], f"{entry_where}.usd_per_mtok", positive=True)
+        if raw.get("rate_card") is not None:
+            cell["rate_card"] = _validate_rate_card(raw["rate_card"], f"{entry_where}.rate_card")
+        validated.append(cell)
+    return validated
+
+
+def _merge_config(base, override, where):
+    table(override, where)
+    unknown_top = set(override) - {"routing", "agents", "state_dir"}
+    if unknown_top:
+        raise AgRouteError(f"{where}: unknown top-level keys {sorted(unknown_top)}")
+    merged = deepcopy(base)
+    if "state_dir" in override:
+        merged["state_dir"] = text(override["state_dir"], f"{where}.state_dir", max_length=1024)
+    if "routing" in override:
+        r_override = table(override["routing"], f"{where}.routing")
+        unknown_r = set(r_override) - {"default_host", "host_affinity_epsilon", "namespace_separator"}
+        if unknown_r:
+            raise AgRouteError(f"{where}.routing: unknown keys {sorted(unknown_r)}")
+        merged["routing"].update(deepcopy(r_override))
+    if "agents" in override:
+        a_override = table(override["agents"], f"{where}.agents")
+        for name, spec in a_override.items():
+            agent_id(name, f"{where}.agents.{name}")
+            table(spec, f"{where}.agents.{name}")
+            unknown_a = set(spec) - {
+                "enabled",
+                "max_session_used_pct",
+                "max_weekly_used_pct",
+                "max_tier_used_pct",
+                "host_reserve_pct",
+                "usage_probe_cmd",
+                "native_candidates",
+                "cli_candidates",
+            }
+            if unknown_a:
+                raise AgRouteError(f"{where}.agents.{name}: unknown keys {sorted(unknown_a)}")
+            merged["agents"][name].update(deepcopy(spec))
+    return merged
+
+
+def _validate_merged(raw):
+    routing = table(raw.get("routing"), "routing")
+    keys(routing, ["default_host", "host_affinity_epsilon", "namespace_separator"], where="routing")
+    default_host = agent_id(routing["default_host"], "routing.default_host")
+    epsilon = number(routing["host_affinity_epsilon"], "routing.host_affinity_epsilon", nonnegative=True)
+    separator = text(routing["namespace_separator"], "routing.namespace_separator", max_length=1)
+    if separator not in ("/", ":"):
+        raise AgRouteError("routing.namespace_separator: expected '/' or ':'")
+
+    agents_raw = table(raw.get("agents"), "agents")
+    keys(agents_raw, AGENTS, where="agents")
+    agents = {}
+    for name in AGENTS:
+        where = f"agents.{name}"
+        spec = table(agents_raw[name], where)
+        keys(
+            spec,
+            [
+                "enabled",
+                "max_session_used_pct",
+                "max_weekly_used_pct",
+                "max_tier_used_pct",
+                "host_reserve_pct",
+                "usage_probe_cmd",
+                "native_candidates",
+                "cli_candidates",
+            ],
+            where=where,
+        )
+        enabled = boolean(spec["enabled"], f"{where}.enabled")
+        max_session = percentage(spec["max_session_used_pct"], f"{where}.max_session_used_pct")
+        max_weekly = percentage(spec["max_weekly_used_pct"], f"{where}.max_weekly_used_pct")
+        max_tier = percentage(spec["max_tier_used_pct"], f"{where}.max_tier_used_pct")
+        reserve = percentage(spec["host_reserve_pct"], f"{where}.host_reserve_pct")
+        if reserve > max_session or reserve > max_weekly:
+            raise AgRouteError(f"{where}.host_reserve_pct: cannot exceed max_session_used_pct or max_weekly_used_pct")
+        probe_cmd = spec["usage_probe_cmd"]
+        if not isinstance(probe_cmd, list) or any(not isinstance(arg, str) or not arg for arg in probe_cmd):
+            raise AgRouteError(f"{where}.usage_probe_cmd: expected a list of non-empty strings")
+        native_cands = _validate_candidate_list(
+            spec["native_candidates"], f"{where}.native_candidates", agent=name
+        )
+        cli_cands = _validate_candidate_list(
+            spec["cli_candidates"], f"{where}.cli_candidates", agent=name
+        )
+        if enabled and not native_cands and not cli_cands:
+            raise AgRouteError(f"{where}: enabled agent must declare at least one candidate")
+        agents[name] = {
+            "enabled": enabled,
+            "max_session_used_pct": max_session,
+            "max_weekly_used_pct": max_weekly,
+            "max_tier_used_pct": max_tier,
+            "host_reserve_pct": reserve,
+            "usage_probe_cmd": list(probe_cmd),
+            "native_candidates": native_cands,
+            "cli_candidates": cli_cands,
+        }
+    return default_host, epsilon, separator, agents
+
+
+def _read_toml(path, where):
+    try:
+        return tomllib.loads(Path(path).read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise AgRouteError(f"{where}: unable to read {path}: {exc}") from exc
+    except tomllib.TOMLDecodeError as exc:
+        raise AgRouteError(f"{where}: invalid TOML in {path}: {exc}") from exc
+
+
+def load_config(path=None, *, project=None, state_directory=None, include_user_config=True):
+    default_bytes = files("agroute").joinpath("data/default_config.toml").read_text(encoding="utf-8")
+    merged = tomllib.loads(default_bytes)
+
+    user_cfg_path = None
+    if include_user_config:
+        env_user = os.environ.get("AGROUTE_USER_CONFIG")
+        if env_user:
+            candidate = Path(env_user).expanduser().resolve()
+            if not candidate.is_file():
+                raise AgRouteError(f"user config: file not found at {candidate}")
+            user_cfg_path = candidate
+        else:
+            xdg = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+            candidate = (xdg / "agroute" / "config.toml").resolve()
+            if candidate.is_file():
+                user_cfg_path = candidate
+        if user_cfg_path is not None:
+            merged = _merge_config(merged, _read_toml(user_cfg_path, "user config"), "user config")
+
+    explicit = path is not None
+    base_dir = Path(project).resolve() if project is not None else Path.cwd().resolve()
+    config_path = None
+    if explicit:
+        config_path = Path(path).expanduser().resolve()
+        if not config_path.is_file():
+            raise AgRouteError(f"config: file not found at {config_path}")
+        if project is None:
+            base_dir = config_path.parent
+        merged = _merge_config(merged, _read_toml(config_path, "config"), "config")
+    else:
+        local_candidate = base_dir / "agroute.toml"
+        if local_candidate.is_file():
+            config_path = local_candidate.resolve()
+            merged = _merge_config(merged, _read_toml(config_path, "config"), "config")
+
+    default_host, epsilon, separator, agents = _validate_merged(merged)
+
+    cfg_state_dir = state_directory
+    if cfg_state_dir is None and "state_dir" in merged:
+        raw_state = Path(merged["state_dir"]).expanduser()
+        anchor = config_path.parent if config_path is not None else base_dir
+        cfg_state_dir = (anchor / raw_state).resolve() if not raw_state.is_absolute() else raw_state.resolve()
+
+    capture_root, state_root, identity_path, project_identity = roots(
+        base_dir,
+        explicit=explicit and project is None,
+        state_directory=cfg_state_dir,
+    )
+    return Config(
+        capture_root=capture_root,
+        state_root=state_root,
+        identity_path=identity_path,
+        project_identity=project_identity,
+        config_path=config_path,
+        user_config_path=user_cfg_path,
+        default_host=default_host,
+        host_affinity_epsilon=epsilon,
+        namespace_separator=separator,
+        agents=agents,
+    )

agroute/data/default_config.toml

@@ -0,0 +1,103 @@
+[routing]
+default_host = "agy"
+host_affinity_epsilon = 0.0
+namespace_separator = "/"
+
+[agents.agy]
+enabled = true
+max_session_used_pct = 90.0
+max_weekly_used_pct = 95.0
+max_tier_used_pct = 95.0
+host_reserve_pct = 0.0
+usage_probe_cmd = []
+
+[[agents.agy.native_candidates]]
+model = "pro"
+effort = "standard"
+tier = "pro"
+
+[[agents.agy.native_candidates]]
+model = "flash"
+effort = "standard"
+tier = "flash"
+
+[[agents.agy.native_candidates]]
+model = "flash_lite"
+effort = "standard"
+tier = "flash_lite"
+
+[[agents.agy.cli_candidates]]
+model = "gemini-2.5-pro"
+effort = "high"
+tier = "pro"
+
+[[agents.agy.cli_candidates]]
+model = "gemini-2.5-flash"
+effort = "medium"
+tier = "flash"
+
+[agents.codex]
+enabled = true
+max_session_used_pct = 90.0
+max_weekly_used_pct = 95.0
+max_tier_used_pct = 95.0
+host_reserve_pct = 0.0
+usage_probe_cmd = []
+
+[[agents.codex.native_candidates]]
+model = "gpt-5.4"
+effort = "high"
+
+[[agents.codex.native_candidates]]
+model = "gpt-5.4"
+effort = "medium"
+
+[[agents.codex.cli_candidates]]
+model = "gpt-5.4"
+effort = "high"
+
+[[agents.codex.cli_candidates]]
+model = "gpt-5.4"
+effort = "medium"
+
+[[agents.codex.cli_candidates]]
+model = "gpt-5.4-mini"
+effort = "low"
+
+[agents.claude]
+enabled = true
+max_session_used_pct = 90.0
+max_weekly_used_pct = 95.0
+max_tier_used_pct = 95.0
+host_reserve_pct = 0.0
+usage_probe_cmd = []
+
+[[agents.claude.native_candidates]]
+model = "claude-opus-4-6"
+effort = "high"
+tier = "opus"
+
+[[agents.claude.native_candidates]]
+model = "claude-sonnet-4-6"
+effort = "high"
+tier = "sonnet"
+
+[[agents.claude.native_candidates]]
+model = "claude-sonnet-4-6"
+effort = "medium"
+tier = "sonnet"
+
+[[agents.claude.cli_candidates]]
+model = "claude-opus-4-6"
+effort = "high"
+tier = "opus"
+
+[[agents.claude.cli_candidates]]
+model = "claude-sonnet-4-6"
+effort = "high"
+tier = "sonnet"
+
+[[agents.claude.cli_candidates]]
+model = "claude-sonnet-4-6"
+effort = "medium"
+tier = "sonnet"

agroute/files.py

@@ -0,0 +1,23 @@
+"""Atomic writes for backend-owned durable state."""
+
+import os
+from pathlib import Path
+import tempfile
+
+
+def atomic_write(path, data):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    name = None
+    try:
+        with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as handle:
+            name = handle.name
+            handle.write(data)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(name, path)
+    finally:
+        if name and os.path.exists(name):
+            os.unlink(name)