wade-cli 0.54.0__tar.gz → 0.54.2__tar.gz

{wade_cli-0.54.0 → wade_cli-0.54.2}/.wade.yml

@@ -7,7 +7,7 @@ project:
   merge_strategy: PR
 ai:
   default_tool: claude
-  default_model: claude-opus-4.8
+  default_model: claude-opus-5
   effort: xhigh
   plan:
     effort: xhigh
@@ -54,7 +54,7 @@ models:
       model: claude-sonnet-5
       effort: xhigh
     very_complex:
-      model: claude-opus-4.8
+      model: claude-opus-5
       effort: xhigh
 provider:
   name: github

{wade_cli-0.54.0 → wade_cli-0.54.2}/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://conventionalcommits.org/).
 
+## [v0.54.2] — 2026-09-02
+
+### Chores
+
+- adopt Crossby 0.28 and Opus defaults (#483) (99e32c1)
+
+## [v0.54.1] — 2026-09-02
+
+### Chores
+
+- adopt Crossby 0.27.0 model catalogs and defaults (#477) (3b3a223)
+
 ## [v0.54.0] — 2026-08-31
 
 ### Features

{wade_cli-0.54.0 → wade_cli-0.54.2}/KNOWLEDGE.md

@@ -689,3 +689,21 @@ annotate_bot_expectations' marker_root is inconsistent across call sites in revi
 The three session skills are hard-capped by tests/integration/test_skill_context_budget.py (BUDGET_CHARS covers launch prompt + rendered SKILL.md with partials expanded); the review-pr-comments skill had only ~170 chars of headroom in v0.50.7, so any new skill rule must be paid for by trimming an existing one. Measure with the rendered size, not the raw template — _partials/ expansion (user-interaction, review-budget, doc-update-step) roughly doubles it.
 
 ---
+
+## cb42b47b0a78 | 2026-09-02 | implementation | tags: crossby, dependencies, testing | Issue #476
+
+Bumping the crossby pin in pyproject.toml also requires updating a hardcoded exact version in tests/unit/test_skills/test_crossby_contract.py (assert version("crossby") == "X.Y.Z") — pyproject is the range source of truth, but that test pins the exact resolved version alongside the semi-private skill-discovery API contract. Change both in the same commit or the suite fails.
+
+---
+
+## c55057c13ebb | 2026-09-02 | implementation | tags: dependencies, crossby, tooling | Issue #476
+
+uv.lock is gitignored in this repo, so a crossby pin bump needs BOTH `uv lock` and `uv pip install -e ".[dev]"` — `uv lock` only rewrites the lockfile and leaves the venv on the old version, so version("crossby") and the whole test suite still run against the previous release. Never commit uv.lock.
+
+---
+
+## caa4604d0d03 | 2026-09-02 | implementation | tags: crossby, documentation, dependencies, model-registry | Issue #476
+
+docs/dev/architecture.md's .wade.yml example hardcodes crossby's claude complexity-tier model IDs, so every crossby pin bump silently makes it stale — wade init writes whatever crossby.config.defaults.get_defaults() returns, not those literals. Update that block on every pin bump; note the crossby version RANGE is deliberately not restated in that file (architecture.md line ~171) so only the tier values need touching. Blast radius on existing projects is narrow: wade update re-resolves defaults but calls _patch_config without force, backfilling only tiers a config left unset.
+
+---

{wade_cli-0.54.0 → wade_cli-0.54.2}/KNOWLEDGE.ratings.jsonl

@@ -139,3 +139,16 @@
 {"dir": "up", "id": "9d1174462f4f", "ts": "2026-08-23T12:02:54.794039+00:00"}
 {"dir": "up", "id": "cc91cd11", "ts": "2026-08-23T12:51:53.485846+00:00"}
 {"dir": "up", "id": "cc91cd11", "ts": "2026-08-23T14:26:37.437348+00:00"}
+{"dir": "up", "event_id": "5af81b1c07f24fe18f9277c5c8194925", "id": "ae5df2be", "ts": "2026-09-02T11:12:02.664986+00:00"}
+{"dir": "up", "event_id": "7fc6df916fd740cfbddf707fdc221377", "id": "a15045c3", "ts": "2026-09-02T11:12:02.858245+00:00"}
+{"dir": "up", "event_id": "57c65a7982544d3ca8570b05355aae6c", "id": "8ee8260b", "ts": "2026-09-02T11:12:03.056495+00:00"}
+{"dir": "up", "event_id": "778f96fb855347ef8ebe126cec1b3e9e", "id": "a44493f7", "ts": "2026-09-02T15:22:01.791564+00:00"}
+{"dir": "up", "event_id": "f801f16d34c947a3a2c6bc6b2ccf93c5", "id": "97d81e85", "ts": "2026-09-02T15:22:02.033543+00:00"}
+{"dir": "up", "event_id": "86b51e9e597345458b1a9766a0788bfb", "id": "ae5df2be", "ts": "2026-09-02T15:22:02.278038+00:00"}
+{"dir": "up", "event_id": "4db30022d5784427a9e5ec78a0ce8511", "id": "9f5e5e2c", "ts": "2026-09-02T15:22:02.524170+00:00"}
+{"dir": "up", "event_id": "783336b5e7a04cd8879dd56d73f2fb1b", "id": "1c18f1d4", "ts": "2026-09-02T15:22:02.772169+00:00"}
+{"dir": "up", "event_id": "341809dc1867428094f1857f627b4d30", "id": "235fb8e8", "ts": "2026-09-02T15:22:03.030022+00:00"}
+{"dir": "up", "event_id": "cda2226d804e4fc698e8e0760b444048", "id": "8ee8260b", "ts": "2026-09-02T15:22:03.280856+00:00"}
+{"dir": "up", "event_id": "0d0c898f52b54710a8d50b82cf78444a", "id": "a15045c3", "ts": "2026-09-02T15:22:03.529067+00:00"}
+{"dir": "up", "event_id": "417925753e00400a98e04c6a7d41ccc4", "id": "ae5df2be", "ts": "2026-09-02T15:39:33.320072+00:00"}
+{"dir": "up", "event_id": "a23ed60deb074def962f804a7ff9541a", "id": "fb2a067bb103", "ts": "2026-09-02T15:39:33.521027+00:00"}

{wade_cli-0.54.0 → wade_cli-0.54.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: wade-cli
-Version: 0.54.0
+Version: 0.54.2
 Summary: WADE — Workflow for AI-Driven Engineering
 Project-URL: Homepage, https://github.com/ivanviragine/wade
 Project-URL: Repository, https://github.com/ivanviragine/wade
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Version Control :: Git
 Requires-Python: >=3.11
-Requires-Dist: crossby<0.25.0,>=0.24.4
+Requires-Dist: crossby<0.29.0,>=0.28.0
 Requires-Dist: httpx<1.0,>=0.27
 Requires-Dist: pydantic-settings>=2.0
 Requires-Dist: pydantic>=2.0

{wade_cli-0.54.0 → wade_cli-0.54.2}/docs/dev/architecture.md

@@ -767,12 +767,12 @@ ai:
     tool: claude
   implement:
     tool: claude
-models:
+models:                      # values below are crossby's claude defaults, not wade constants
   claude:
     easy: claude-haiku-4.5
-    medium: claude-haiku-4.5
-    complex: claude-sonnet-4.6
-    very_complex: claude-opus-4.6
+    medium: claude-sonnet-5
+    complex: claude-sonnet-5
+    very_complex: claude-opus-5
 provider:
   name: github
 hooks:
@@ -957,6 +957,8 @@ exactly as before #448. See knowledge `cc91cd11` for the generalized principle.
 
 **Model complexity mapping**: The `models` section maps AI tool names to complexity-tiered model IDs (`easy`, `medium`, `complex`, `very_complex`). When `wade implement` is invoked, the service reads the `complexity:X` label from the issue (falling back to `## Complexity` in the body), maps it to the appropriate configured model, and passes it as `--model` to the AI tool — unless the user explicitly passed `--model` themselves.
 
+The tier values `wade init` writes are **not wade constants** — `init_service/config_io.py::_resolve_models()` seeds them from `crossby.config.defaults.get_defaults(tool)`, so **bumping the crossby pin changes what newly initialized projects get**. The example above shows crossby's `claude` defaults at the currently pinned version; run `get_defaults()` for the authoritative set rather than trusting a doc snapshot, and re-check this block on every crossby bump. A bump does **not** rewrite tiers an existing `.wade.yml` already sets: `wade update` re-resolves the defaults and calls `_patch_config` without `force`, which backfills only *absent* tiers. So a fresh `wade init` picks up the new defaults wholesale, while an existing project changes only where it left a tier unset.
+
 **Per-command AI tool and model overrides**: The `ai` section supports `plan`, `deps`, `implement`, `review_plan`, `review_implementation`, `review_batch`, and `review_pr_comments` sub-sections (`AI_COMMAND_NAMES` in `models/config.py`), with optional `tool`, `model`, `mode`, `effort`, `enabled`, `yolo`, `permission_mode`, `network_access`, and `timeout` keys as applicable. `network_access` (global `ai.network_access` or per-command) is the Codex sandbox network pin resolved by `resolve_network_access()`: it defaults to **True** for `implement` and `review_pr_comments`, whose lifecycle requires GitHub, and **False** for every other command. The CLI, per-command, and global policy levels remain higher-precedence opt-outs — see the "Codex sandboxed-worktree git writes & network policy" section above. `timeout` bounds a headless subprocess (seconds). When **unset**, the review/deps services compute the budget with `effective_timeout` (`delegation_service.py`, #366): it scales from **payload bytes + reasoning effort** — `scaled_timeout` starts at a **600s floor** (`TIMEOUT_FLOOR`, covers CLI cold-start + a small high-effort run), adds ~0.0075 s/byte of prompt, multiplies high/xhigh/max effort by 1.5–1.75×, and clamps to a **1500s ceiling** (`TIMEOUT_CEILING`). A headless timeout is **not** discarded: `run` (`utils/process.py`) decodes and reattaches the partial stdout (bytes even under `text=True`), `_delegate_headless` returns it as `feedback` with `DelegationResult.timed_out=True`, and wade **retries once** at a longer budget (`extended_timeout`, 1.5×) — bounding the *sum* of both legs to `TOTAL_TIMEOUT_CAP` (`TIMEOUT_CEILING + TIMEOUT_CEILING * TIMEOUT_RETRY_MULTIPLIER`, ~3750s / 62.5 min) so the worst case is predictable while the retry always gets the full multiplier, never a shorter budget than the attempt that just timed out (#366 review). The pre-launch advisory — now also printed by `deps_service.analyze_deps` before a headless run, not just the review commands (#366 review) — announces that worst-case total. A crash (`CommandError` / non-zero exit) is never retried and never flagged `timed_out`. Setting `ai.<cmd>.timeout` **explicitly** is a deliberate override: it is honored verbatim and **bypasses scaling and the retry math** — the escape hatch for orchestrators with a hard tool-timeout (set it below the harness limit). The fallback chain (tool/model) is: CLI `--ai`/`--model` flag -> command-specific config -> global `default_tool`. This is implemented in `ProjectConfig.get_ai_tool(command)` and `ProjectConfig.get_model(command)`. When `mode` is omitted, `review_plan` and `review_implementation` default to `prompt`, while `review_batch` defaults to `interactive`. `review_pr_comments` (#389) governs the **auto-launched review session** (post-`done` "Wait for reviews" → comments land → `review_service.start`): it resolves that session's tool, model, effort, and autonomy tier under its own key rather than inheriting `ai.implement.*`. The inherited implementation-session `tool` / `model` / `permission_mode` are honored only when the user set them *explicitly* (`--ai` / `--model` / `--permission-mode` / `--yolo`); the implementation flow forwards its already-*resolved* concrete values (never `None`), which would otherwise short-circuit the resolvers and shadow `ai.review_pr_comments` — so a merely config/default-derived value is dropped and the review config (then global `ai.*`) governs.
 
 **Permission (autonomy) mode vs. delegation `mode` — two orthogonal axes**: The `mode` key (`DelegationMode`: `prompt`/`interactive`/`headless`, `models/delegation.py`) governs *how* a tool is dispatched. `permission_mode` (`PermissionMode`: `default`/`accept-edits`/`auto`/`yolo`, `models/permission.py`) governs *how much* the tool may do without prompting — the autonomy axis crossby exposes via the `yolo`/`auto`/`accept_edits` launch booleans. Do **not** conflate them: they live in separate modules on purpose. Resolution (`resolve_permission_mode()` in `ai_resolution.py`) follows CLI `--permission-mode` > `--yolo` alias > command config > global config > `default`; `permission_mode` wins over the legacy `yolo` alias at any level, and `get_yolo()`/`resolve_yolo()` are thin shims that derive from the resolved mode so the alias has a single source of truth. WADE forwards only the *requested* tier and does **not** gate on per-tool capability — crossby owns capability-aware downgrades and warnings (`_autonomy_launch_args`), so `auto` on a non-Claude tool downgrades to `accept-edits` instead of WADE silently disabling it. The headless delegation path always forces `default` (no autonomy grant) regardless of config, since `deps`/`review_plan`/`review_implementation`/`review_batch` are read/analytical; `review_pr_comments` is the exception — it launches an *interactive* session and honors its configured `ai.review_pr_comments.permission_mode`. `plan` is intentionally excluded from `PermissionMode` (WADE drives plan mode separately via `plan_service` → `plan_mode=True` for native plan tools, and `plan_mode=False` for Antigravity CLI whose native plan mode sandboxes writes to an external brain store while WADE's plan-artifact guard enforces containment); a configured or CLI-supplied `permission_mode: plan` (or any invalid value) warns and falls back to `default`. Every launch command (`plan`, `implement`, `implement-batch`, `review pr-comments`, `review plan`/`implementation`/`batch`, `task deps`, and the delegation paths) exposes `--yolo`/`--permission-mode` and resolves + forwards the tier; `confirm_ai_selection()` (`ai_resolution.py`) **always displays** the resolved tool/model/effort/permission mode with a per-tier descriptor (`permission.describe_permission_mode`) before its skip guard, so the mode surfaces on every path (TTY, non-TTY, headless, all-flags-explicit) and what is shown always equals what is applied. For the read-only headless paths (`deps`/`review_*` in headless mode), the service computes the *effective* mode as `default` and uses that single value for both display and the `DelegationRequest`, mirroring the `delegation_service` headless force-default rule. In addition, a completed non-zero headless exit preserves trimmed stdout and appends a clearly labeled stderr tail (the final 20 non-empty lines, capped at 4,000 characters, with truncation labeled); only failures with neither stream retain the generic no-output fallback.

{wade_cli-0.54.0 → wade_cli-0.54.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wade-cli"
-version = "0.54.0"
+version = "0.54.2"
 description = "WADE — Workflow for AI-Driven Engineering"
 readme = "README.md"
 license = "MIT"
@@ -24,7 +24,7 @@ classifiers = [
     "Topic :: Software Development :: Version Control :: Git",
 ]
 dependencies = [
-    "crossby>=0.24.4,<0.25.0",
+    "crossby>=0.28.0,<0.29.0",
     "typer>=0.12,<0.26",
     "pydantic>=2.0",
     "pydantic-settings>=2.0",

{wade_cli-0.54.0 → wade_cli-0.54.2}/src/wade/__init__.py

@@ -1,3 +1,3 @@
 """WADE (Workflow for AI-Driven Engineering) — AI-agent-driven git workflow management CLI."""
 
-__version__ = "0.54.0"
+__version__ = "0.54.2"

wade_cli-0.54.2/tests/unit/test_cli/test_autocomplete.py

@@ -0,0 +1,122 @@
+"""Model autocompletion reads Crossby's catalog at runtime, never a wade copy.
+
+Every expectation here is derived from ``crossby.data.MODELS`` rather than
+hardcoded, so a Crossby version bump that changes the catalog cannot make these
+tests stale — it can only make them fail if ``complete_models`` stops tracking
+the catalog. Re-run on every Crossby dependency change.
+
+Two assertions are deliberate *vacuity guards* rather than assertions about
+``complete_models``: they check that the live catalog still has the shape a test
+needs to prove anything (Claude and Codex catalogs differing; some cross-tool
+overlap existing). A catalog reshaped enough to break one of those premises will
+fail the guard, and its message names that cause so the failure is not misread
+as a wade regression. They are kept because without them the test they guard
+passes vacuously, which is the worse failure mode.
+"""
+
+from __future__ import annotations
+
+import click
+import pytest
+import typer
+from crossby.data import MODELS
+from crossby.models.ai import AIToolID
+
+from wade.cli.autocomplete import complete_models
+
+_CLAUDE = AIToolID.CLAUDE.value
+_CODEX = AIToolID.CODEX.value
+
+
+def test_crossby_0_28_exposes_gemini_3_8_for_supported_tools() -> None:
+    assert "gemini-3.8-flash" in MODELS[AIToolID.ANTIGRAVITY_CLI.value]
+    assert {
+        "gemini-3.8-flash-low",
+        "gemini-3.8-flash-medium",
+        "gemini-3.8-flash-high",
+    }.issubset(MODELS[AIToolID.CURSOR.value])
+    assert "google/gemini-3.8-flash" in MODELS[AIToolID.OPENCODE.value]
+
+
+def _ctx(ai: str | list[str] | None = None) -> typer.Context:
+    """A Typer context carrying the ``--ai`` param exactly as Click would."""
+    ctx = typer.Context(click.Command("wade"))
+    if ai is not None:
+        ctx.params["ai"] = ai
+    return ctx
+
+
+def _catalog(*tools: str) -> list[str]:
+    """Sorted, deduplicated Crossby models for ``tools`` (all tools when empty)."""
+    keys = tools or tuple(MODELS)
+    return sorted({model for key in keys for model in MODELS.get(key, [])})
+
+
+@pytest.fixture(scope="module")
+def claude_prefix() -> str:
+    """A prefix taken from the live catalog that filters Claude's models strictly."""
+    models = _catalog(_CLAUDE)
+    prefix = models[0][:8]
+    assert [m for m in models if m.startswith(prefix)] != models, (
+        f"prefix {prefix!r} matches every Claude model — it cannot prove filtering"
+    )
+    return prefix
+
+
+class TestCompleteModelsWithExplicitTool:
+    """With ``--ai`` present, completion stays scoped to the selected tool(s)."""
+
+    def test_returns_the_full_catalog_for_that_tool(self) -> None:
+        expected = _catalog(_CLAUDE)
+        assert expected, "crossby exposes no Claude models"
+        assert complete_models(_ctx(_CLAUDE), "") == expected
+
+    def test_excludes_models_belonging_only_to_another_tool(self) -> None:
+        codex_only = set(MODELS.get(_CODEX, [])) - set(MODELS.get(_CLAUDE, []))
+        assert codex_only, "crossby's codex and claude catalogs no longer differ"
+        assert codex_only.isdisjoint(complete_models(_ctx(_CLAUDE), ""))
+
+    def test_filters_by_prefix(self, claude_prefix: str) -> None:
+        result = complete_models(_ctx(_CLAUDE), claude_prefix)
+        assert result, f"no Claude model starts with {claude_prefix!r}"
+        assert result == [m for m in _catalog(_CLAUDE) if m.startswith(claude_prefix)]
+        assert set(result) < set(_catalog(_CLAUDE))
+
+    def test_repeated_flag_unions_the_selected_catalogs(self) -> None:
+        assert complete_models(_ctx([_CLAUDE, _CODEX]), "") == _catalog(_CLAUDE, _CODEX)
+
+    def test_the_same_tool_twice_is_deduplicated(self) -> None:
+        """Dedup holds by construction, without relying on tools sharing models.
+
+        The union case above pairs Claude with Codex, whose catalogs are
+        disjoint today, so it never actually exercises deduplication on this
+        branch. Repeating one tool forces every candidate to collide.
+        """
+        assert complete_models(_ctx([_CLAUDE, _CLAUDE]), "") == _catalog(_CLAUDE)
+
+    def test_unknown_tool_yields_no_candidates(self) -> None:
+        assert complete_models(_ctx("not-a-tool"), "") == []
+
+
+class TestCompleteModelsWithoutTool:
+    """With no ``--ai``, completion spans the whole deduplicated catalog."""
+
+    def test_returns_every_catalog_entry_deduplicated(self) -> None:
+        expected = _catalog()
+        result = complete_models(_ctx(), "")
+        assert result == expected
+        assert len(result) == len(set(result))
+        assert len(result) < sum(len(models) for models in MODELS.values()), (
+            "no tool catalogs overlap, so deduplication is untested"
+        )
+
+    def test_is_a_superset_of_the_tool_scoped_result(self) -> None:
+        assert set(complete_models(_ctx(_CLAUDE), "")) < set(complete_models(_ctx(), ""))
+
+    def test_filters_by_prefix(self, claude_prefix: str) -> None:
+        result = complete_models(_ctx(), claude_prefix)
+        assert result == [m for m in _catalog() if m.startswith(claude_prefix)]
+        assert all(m.startswith(claude_prefix) for m in result)
+
+    def test_unmatched_prefix_yields_no_candidates(self) -> None:
+        assert complete_models(_ctx(), "zzz-no-such-model") == []

{wade_cli-0.54.0 → wade_cli-0.54.2}/tests/unit/test_skills/test_crossby_contract.py

@@ -27,7 +27,7 @@ def _skill(root: Path, relative: str, name: str) -> Path:
 
 
 def test_crossby_version_and_skill_root_mapping_contract() -> None:
-    assert version("crossby") == "0.24.4"
+    assert version("crossby") == "0.28.0"
     assert SKILLS_DIR == {
         AIToolID.CLAUDE: ".claude/skills",
         AIToolID.CURSOR: ".cursor/skills",