agentic-dev-loop 1.0.0b1__tar.gz → 1.0.0rc3__tar.gz

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0b1
+Version: 1.0.0rc3
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -44,6 +44,7 @@ Requires-Dist: hypothesis>=6.0; extra == "dev"
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pip-audit>=2.0; extra == "dev"
 Requires-Dist: pre-commit>=3.0; extra == "dev"
+Requires-Dist: setuptools>=78.1.1; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: mkdocs-material~=9.6; extra == "docs"
 Requires-Dist: pymdown-extensions~=10.0; extra == "docs"
@@ -108,12 +109,12 @@ Docker engine does:
 | --- | --- |
 | Python | >= 3.12 |
 | Docker engine | Engine API >= 1.43 (Engine 24). Any compliant engine works - Docker Desktop, OrbStack, Colima, Rancher Desktop, podman docker-compat. On Windows, run under WSL2: the repo must live on the WSL filesystem, not /mnt/c. |
-| LLM API key | The env var named by your pipeline's `api_key_env` (e.g. `OPENAI_API_KEY`) must be set - a missing key fails fast, naming it. Alternatively, `agentic-dev-loop copilot-login` authenticates a Copilot subscription (see [LLM providers](https://lukedawilson.github.io/agentic-dev-loop/llm-providers/)). |
+| LLM API key | The env var named by your pipeline's `api_key_env` (e.g. `OPENAI_API_KEY`) must be set - a missing key fails fast, naming it. Alternatively, `agentic-dev-loop copilot-login` authenticates a Copilot subscription, and a Claude Pro or Max subscription runs on Anthropic's own endpoint after `agentic-dev-loop claude-login` (see [LLM providers](https://lukedawilson.github.io/agentic-dev-loop/llm-providers/)). |
 
 ### Installation
 
 ```bash
-pipx install agentic-dev-loop
+pipx install --pip-args="--pre" agentic-dev-loop   # latest release is currently a pre-release
 agentic-dev-loop --version
 ```
 
@@ -181,7 +182,7 @@ policy, named LLM profiles - is in the
 | [Architecture](https://lukedawilson.github.io/agentic-dev-loop/architecture/) | The five layers, one full run end to end, and the host-boundary security model |
 | [CLI](https://lukedawilson.github.io/agentic-dev-loop/cli/) | Run flags, resuming, the live view, reports, container management, and onboarding commands |
 | [pipeline.yaml](https://lukedawilson.github.io/agentic-dev-loop/pipeline/) | The complete configuration reference: steps, isolation, secrets, networking, dependency policy |
-| [LLM providers](https://lukedawilson.github.io/agentic-dev-loop/llm-providers/) | OpenAI-compatible endpoints (OpenAI, DeepSeek, and others) and the GitHub Copilot subscription |
+| [LLM providers](https://lukedawilson.github.io/agentic-dev-loop/llm-providers/) | OpenAI-compatible endpoints (OpenAI, DeepSeek, and others), the GitHub Copilot subscription, and the Claude subscription |
 | [Authoring a loop](https://lukedawilson.github.io/agentic-dev-loop/authoring/) | From `init` to a committed pipeline: agent files, stage lineup, adaptation checklist |
 | [Setup and troubleshooting](https://lukedawilson.github.io/agentic-dev-loop/setup/) | Docker engines, the dev image, caching, error codes |
 | [Browser sandbox](https://lukedawilson.github.io/agentic-dev-loop/browser-sandbox/) | Running a browser inside the sandbox |

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/README.md

@@ -57,12 +57,12 @@ Docker engine does:
 | --- | --- |
 | Python | >= 3.12 |
 | Docker engine | Engine API >= 1.43 (Engine 24). Any compliant engine works - Docker Desktop, OrbStack, Colima, Rancher Desktop, podman docker-compat. On Windows, run under WSL2: the repo must live on the WSL filesystem, not /mnt/c. |
-| LLM API key | The env var named by your pipeline's `api_key_env` (e.g. `OPENAI_API_KEY`) must be set - a missing key fails fast, naming it. Alternatively, `agentic-dev-loop copilot-login` authenticates a Copilot subscription (see [LLM providers](https://lukedawilson.github.io/agentic-dev-loop/llm-providers/)). |
+| LLM API key | The env var named by your pipeline's `api_key_env` (e.g. `OPENAI_API_KEY`) must be set - a missing key fails fast, naming it. Alternatively, `agentic-dev-loop copilot-login` authenticates a Copilot subscription, and a Claude Pro or Max subscription runs on Anthropic's own endpoint after `agentic-dev-loop claude-login` (see [LLM providers](https://lukedawilson.github.io/agentic-dev-loop/llm-providers/)). |
 
 ### Installation
 
 ```bash
-pipx install agentic-dev-loop
+pipx install --pip-args="--pre" agentic-dev-loop   # latest release is currently a pre-release
 agentic-dev-loop --version
 ```
 
@@ -130,7 +130,7 @@ policy, named LLM profiles - is in the
 | [Architecture](https://lukedawilson.github.io/agentic-dev-loop/architecture/) | The five layers, one full run end to end, and the host-boundary security model |
 | [CLI](https://lukedawilson.github.io/agentic-dev-loop/cli/) | Run flags, resuming, the live view, reports, container management, and onboarding commands |
 | [pipeline.yaml](https://lukedawilson.github.io/agentic-dev-loop/pipeline/) | The complete configuration reference: steps, isolation, secrets, networking, dependency policy |
-| [LLM providers](https://lukedawilson.github.io/agentic-dev-loop/llm-providers/) | OpenAI-compatible endpoints (OpenAI, DeepSeek, and others) and the GitHub Copilot subscription |
+| [LLM providers](https://lukedawilson.github.io/agentic-dev-loop/llm-providers/) | OpenAI-compatible endpoints (OpenAI, DeepSeek, and others), the GitHub Copilot subscription, and the Claude subscription |
 | [Authoring a loop](https://lukedawilson.github.io/agentic-dev-loop/authoring/) | From `init` to a committed pipeline: agent files, stage lineup, adaptation checklist |
 | [Setup and troubleshooting](https://lukedawilson.github.io/agentic-dev-loop/setup/) | Docker engines, the dev image, caching, error codes |
 | [Browser sandbox](https://lukedawilson.github.io/agentic-dev-loop/browser-sandbox/) | Running a browser inside the sandbox |

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0b1"
+version = "1.0.0rc3"
 description = "Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -84,6 +84,11 @@ dev = [
     "pytest>=8.0",
     "pip-audit>=2.0",
     "pre-commit>=3.0",
+    # tests/test_viz_wheel_contents.py builds a wheel with
+    # --no-build-isolation so the suite never needs PyPI; the backend must be
+    # importable from this environment. Floor pinned past CVE-2025-47273
+    # (fixed in 78.1.1) so the restore step's pip-audit stays green.
+    "setuptools>=78.1.1",
 ]
 docs = [
     "mkdocs-material~=9.6",

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/src/agentic_dev_loop/core/config.py

@@ -903,7 +903,7 @@ def _custom_prompt_looks_like_path(value: str) -> bool:
     """040/D2: a value counts as path-shaped when it carries a path
     separator or a file extension (a dot). A path-shaped value that names no
     existing file is a hard error, never silent text."""
-    return "/" in value or "\\" in value or Path(value).suffix != ""
+    return "/" in value or "\\" in value or Path(value.rstrip(".")).suffix != ""
 
 
 def resolve_custom_prompt(value: str, pipeline_dir: Path, step_name: str) -> str:

agentic_dev_loop-1.0.0rc3/src/agentic_dev_loop/engine/claude_auth.py

@@ -0,0 +1,301 @@
+"""Claude subscription OAuth PKCE flow (066).
+
+The Claude subscription endpoint consumes a Claude Code OAuth access token.
+``claude-login`` runs the same first-party PKCE flow and writes the token
+file the engine's ``api_key_secret`` FileProvider reads; it never runs
+during a pipeline run. Login only: refresh-on-read is a follow-up plan, so
+the refresh token is persisted now and the file schema stays put.
+
+The token exchange uses a system ``curl`` subprocess, not urllib: the
+Cloudflare edge in front of platform.claude.com answers urllib with 403
+1010 "Access denied based on your browser's signature", while system curl
+reaches the API. A missing curl is a loud error, never a urllib fallback.
+
+The default client id is Claude Code's own first-party OAuth app id, the
+same borrow pattern the Copilot path uses with OpenCode's app, and is
+overridable via ``AGENTIC_DEV_LOOP_CLAUDE_CLIENT_ID``.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import secrets
+import subprocess
+import threading
+import urllib.parse
+import webbrowser
+from datetime import datetime, timedelta, timezone
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+
+AUTHORIZE_URL = "https://claude.com/cai/oauth/authorize"
+TOKEN_ENDPOINT = "https://platform.claude.com/v1/oauth/token"
+TOKEN_PATH = Path("~/.agentic-dev-loop/auth/claude.json")
+
+CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
+CLIENT_ID_ENV = "AGENTIC_DEV_LOOP_CLAUDE_CLIENT_ID"
+SCOPES = (
+    "org:create_api_key user:profile user:inference "
+    "user:sessions:claude_code user:mcp_servers user:file_upload "
+    "user:plugins")
+
+CURL_TIMEOUT = 60
+CALLBACK_TIMEOUT = 300
+REQUIRED_TOKEN_FIELDS = ("access_token", "refresh_token", "expires_in")
+
+
+class ClaudeAuthError(RuntimeError):
+    """A loud fail-fast auth failure naming the operator's next step."""
+
+
+def client_id() -> str:
+    """The OAuth app id: the overridable env var, else the pinned default."""
+    return os.environ.get(CLIENT_ID_ENV) or CLAUDE_CLIENT_ID
+
+
+def _b64url(raw: bytes) -> str:
+    return base64.urlsafe_b64encode(raw).rstrip(b"=").decode("ascii")
+
+
+def pkce_pair(rng=os.urandom) -> tuple[str, str]:
+    """A 32-byte PKCE verifier and its S256 challenge, base64url unpadded."""
+    verifier = _b64url(rng(32))
+    challenge = _b64url(hashlib.sha256(verifier.encode("ascii")).digest())
+    return verifier, challenge
+
+
+def authorize_url(redirect_uri: str, code_challenge: str, state: str,
+                  client_id_value: str | None = None) -> str:
+    """The captured authorize URL shape, parameter order included."""
+    params = [
+        ("code", "true"),
+        ("client_id", client_id_value or client_id()),
+        ("response_type", "code"),
+        ("redirect_uri", redirect_uri),
+        ("scope", SCOPES),
+        ("code_challenge", code_challenge),
+        ("code_challenge_method", "S256"),
+        ("state", state),
+    ]
+    query = urllib.parse.urlencode(params, safe=":/")
+    return f"{AUTHORIZE_URL}?{query}"
+
+
+def _run_curl(argv: list[str]) -> subprocess.CompletedProcess:
+    try:
+        return subprocess.run(argv, capture_output=True, text=True,
+                              timeout=CURL_TIMEOUT, check=False)
+    except subprocess.TimeoutExpired as e:
+        raise ClaudeAuthError(
+            "the Claude token endpoint did not respond within "
+            f"{CURL_TIMEOUT}s - retry `agentic-dev-loop claude-login`") from e
+
+
+def _missing_curl() -> ClaudeAuthError:
+    return ClaudeAuthError(
+        "curl is required for the Claude token exchange but was not found "
+        "on PATH - install curl and run `agentic-dev-loop claude-login` again")
+
+
+def _parse_response(output: str, returncode: int, stderr: str,
+                    token_endpoint: str) -> tuple[str, int]:
+    if "\n" not in output:
+        detail = output.strip() or stderr.strip() or f"curl exit {returncode}"
+        raise ClaudeAuthError(
+            f"curl did not return an HTTP status from {token_endpoint}: "
+            f"{detail}")
+    body, _, status_text = output.rpartition("\n")
+    try:
+        return body, int(status_text.strip())
+    except ValueError as e:
+        raise ClaudeAuthError(
+            f"could not read the HTTP status from curl output for "
+            f"{token_endpoint}: {status_text.strip() or 'empty'}") from e
+
+
+def exchange_token(code: str, redirect_uri: str, code_verifier: str,
+                   state: str, *, token_endpoint: str = TOKEN_ENDPOINT,
+                   curl_runner=None) -> dict:
+    """Exchange the authorization code for tokens via system curl."""
+    body = json.dumps({
+        "grant_type": "authorization_code",
+        "code": code,
+        "redirect_uri": redirect_uri,
+        "client_id": client_id(),
+        "code_verifier": code_verifier,
+        "state": state,
+    }, separators=(",", ":"))
+    argv = [
+        "curl", "-sS",
+        "-X", "POST", token_endpoint,
+        "-H", "Content-Type: application/json",
+        "-H", "Accept: application/json",
+        "--data-binary", body,
+        "-w", "\n%{http_code}",
+    ]
+    runner = curl_runner or _run_curl
+    try:
+        completed = runner(argv)
+    except FileNotFoundError as e:
+        raise _missing_curl() from e
+    body_text, status = _parse_response(
+        completed.stdout or "", completed.returncode,
+        completed.stderr or "", token_endpoint)
+    detail = body_text.strip()[:500]
+    if status == 429:
+        raise ClaudeAuthError(
+            "the token endpoint is rate limited (HTTP 429): "
+            f"{detail or 'rate_limit_error'}; retry in a few minutes by "
+            "running `agentic-dev-loop claude-login` again")
+    if status != 200:
+        raise ClaudeAuthError(
+            f"the token exchange failed (HTTP {status}): "
+            f"{detail or 'no response body'}")
+    try:
+        payload = json.loads(body_text)
+    except json.JSONDecodeError as e:
+        raise ClaudeAuthError(
+            "the token endpoint returned a non-JSON response (HTTP 200): "
+            f"{detail}") from e
+    if not isinstance(payload, dict):
+        raise ClaudeAuthError(
+            "the token endpoint returned a JSON value that is not an object")
+    missing = [name for name in REQUIRED_TOKEN_FIELDS
+               if not _present(payload.get(name))]
+    if missing:
+        raise ClaudeAuthError(
+            "the token endpoint response is missing required field(s): "
+            + ", ".join(missing))
+    return payload
+
+
+def _present(value) -> bool:
+    if isinstance(value, str):
+        return bool(value)
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _expires_in_seconds(value) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError) as e:
+        raise ClaudeAuthError(
+            f"the token endpoint returned a non-numeric expires_in: {value!r}"
+        ) from e
+
+
+def write_token(token: dict, token_path: Path | str | None = None) -> Path:
+    """Write access token, refresh token, and absolute expiry with mode 600."""
+    access = token.get("access_token")
+    refresh = token.get("refresh_token")
+    if not isinstance(access, str) or not access:
+        raise ClaudeAuthError("the token payload has no access_token")
+    if not isinstance(refresh, str) or not refresh:
+        raise ClaudeAuthError("the token payload has no refresh_token")
+    expires_at = (datetime.now(timezone.utc)
+                  + timedelta(seconds=_expires_in_seconds(
+                      token.get("expires_in"))))
+    payload = {
+        "access_token": access,
+        "refresh_token": refresh,
+        "expires_at": expires_at.isoformat(),
+    }
+    path = (Path(token_path).expanduser() if token_path
+            else TOKEN_PATH.expanduser())
+    path.parent.mkdir(parents=True, exist_ok=True)
+    text = json.dumps(payload, indent=2, sort_keys=True) + "\n"
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as handle:
+        handle.write(text)
+    os.chmod(path, 0o600)
+    return path
+
+
+class _CallbackServer(HTTPServer):
+    expected_state: str
+    result: dict[str, str]
+
+
+class _CallbackHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        server = self.server
+        params = urllib.parse.parse_qs(
+            urllib.parse.urlsplit(self.path).query)
+        state = (params.get("state") or [""])[0]
+        if state != server.expected_state:
+            server.result["error"] = "state mismatch in the OAuth callback"
+            self._respond(400, "Claude login failed: state mismatch. "
+                               "Close this window and run "
+                               "`agentic-dev-loop claude-login` again.")
+            return
+        error = (params.get("error") or [""])[0]
+        if error:
+            server.result["error"] = error
+            self._respond(400, f"Claude login failed: {error}. Close this "
+                               "window and run `agentic-dev-loop claude-login` "
+                               "again.")
+            return
+        code = (params.get("code") or [""])[0]
+        if not code:
+            server.result["error"] = "the OAuth callback carried no code"
+            self._respond(400, "Claude login failed: no authorization code.")
+            return
+        server.result["code"] = code
+        self._respond(200, "Claude login complete. You can close this window.")
+
+    def _respond(self, status: int, message: str) -> None:
+        body = (message + "\n").encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "text/plain; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, fmt, *args):
+        pass
+
+
+def login(token_path: Path | str | None = None, *, opener=None,
+          token_endpoint: str = TOKEN_ENDPOINT, curl_runner=None,
+          printer=print,
+          callback_timeout: float = CALLBACK_TIMEOUT) -> dict:
+    """Run the PKCE flow and persist the token; never called by a pipeline."""
+    verifier, challenge = pkce_pair()
+    state = secrets.token_urlsafe(32)
+    result: dict[str, str] = {}
+    server = _CallbackServer(("127.0.0.1", 0), _CallbackHandler)
+    server.expected_state = state
+    server.result = result
+    port = server.server_address[1]
+    redirect_uri = f"http://localhost:{port}/callback"
+    url = authorize_url(redirect_uri, challenge, state)
+    open_browser = opener or webbrowser.open
+    printer(f"Open this URL to authorize Claude: {url}")
+    thread = threading.Thread(target=server.handle_request, daemon=True)
+    thread.start()
+    try:
+        open_browser(url)
+        thread.join(callback_timeout)
+    finally:
+        server.server_close()
+    if thread.is_alive():
+        raise ClaudeAuthError(
+            "timed out waiting for the browser callback - run "
+            "`agentic-dev-loop claude-login` again")
+    if result.get("error"):
+        raise ClaudeAuthError(
+            f"authorization failed: {result['error']} - run "
+            "`agentic-dev-loop claude-login` again")
+    code = result.get("code")
+    if not code:
+        raise ClaudeAuthError(
+            "the OAuth callback carried no authorization code - run "
+            "`agentic-dev-loop claude-login` again")
+    token = exchange_token(code, redirect_uri, verifier, state,
+                           token_endpoint=token_endpoint,
+                           curl_runner=curl_runner)
+    write_token(token, token_path)
+    return token

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/src/agentic_dev_loop/engine/cli.py

@@ -14,6 +14,9 @@ import threading
 from pathlib import Path
 
 from agentic_dev_loop.core.config import PipelineConfig, load_config
+from .claude_auth import TOKEN_PATH as CLAUDE_TOKEN_PATH
+from .claude_auth import ClaudeAuthError
+from .claude_auth import login as claude_login
 from .copilot_auth import (TOKEN_PATH, CopilotAuthError, list_copilot_models,
                            login, read_token)
 from .containers import containers_report
@@ -35,6 +38,7 @@ a loud error). Run `agentic-dev-loop <PIPELINE> --help` for
 loader-contributed options (e.g. --plan, --aidlc-unit).
 
 commands:
+  claude-login     Run the Claude OAuth PKCE flow and store the token.
   containers       Inspect engine sandbox containers and networks.
   copilot-login    Run the GitHub device flow and store the Copilot OAuth token.
   copilot-models   List the Copilot models available to this token's tier.
@@ -192,8 +196,31 @@ def _print_containers_report(report) -> None:
               f"run={run} pid={pid_s}")
 
 
-def _token_path(value: str | None) -> Path:
-    return Path(value).expanduser() if value else TOKEN_PATH.expanduser()
+def _token_path(value: str | None, default: Path = TOKEN_PATH) -> Path:
+    return Path(value).expanduser() if value else default.expanduser()
+
+
+def _claude_login_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="agentic-dev-loop claude-login",
+        description="Run the Claude subscription OAuth flow and store the "
+                    "token.")
+    parser.add_argument("--token-file", default=None,
+                        help="token path (default: "
+                             "~/.agentic-dev-loop/auth/claude.json)")
+    return parser
+
+
+def _run_claude_login(argv: list[str]) -> int:
+    args = _claude_login_parser().parse_args(argv)
+    path = _token_path(args.token_file, CLAUDE_TOKEN_PATH)
+    try:
+        claude_login(token_path=path)
+    except ClaudeAuthError as e:
+        print(f"claude-login: {e}", file=sys.stderr)
+        return 1
+    print(f"Claude token written to {path}")
+    return 0
 
 
 def _copilot_login_parser() -> argparse.ArgumentParser:
@@ -425,6 +452,8 @@ def main(argv: list[str] | None = None, *, keep_alive: bool = True) -> int:
             return 2
         print(_TOP_HELP)
         return 0
+    if argv and argv[0] == "claude-login":
+        return _run_claude_login(argv[1:])
     if argv and argv[0] == "containers":
         return _run_containers(argv[1:])
     if argv and argv[0] == "copilot-login":

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/src/agentic_dev_loop/engine/hostboundary.py

@@ -58,7 +58,8 @@ def check_orchestrator_install(workspace: str | Path,
         raise HostBoundaryError(
             f"agentic_dev_loop resolves to {resolved}, inside the workspace "
             f"{ws} - the engine must be installed outside the workspace "
-            "(e.g. `pipx install agentic-dev-loop`); refusing to run")
+            "(e.g. `pipx install --pip-args=--pre agentic-dev-loop`); "
+            "refusing to run")
 
 
 def tooling_rel_paths(cfg: "PipelineConfig", pipeline_path: str | Path,

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/src/agentic_dev_loop/engine/llm.py

@@ -48,6 +48,18 @@ def _reasoning_stripped_error(llm: LLM) -> RuntimeError:
     )
 
 
+def _with_billing_prefix(llm: LLM, out: list[dict]) -> list[dict]:
+    """Claude subscription policy (provider_wire.py): the gateway demands an
+    ``x-anthropic-billing-header`` entry in the FIRST system text block of
+    every request (else 429). The adapter-carried prefix lands as its own
+    system dict at index 0, ahead of the pipeline's real system prompt;
+    litellm preserves system-message order into the Messages API body."""
+    prefix = getattr(llm, "_agentic_dev_loop_system_prefix", None)
+    if prefix:
+        out.insert(0, {"role": "system", "content": prefix})
+    return out
+
+
 if not getattr(_ORIGINAL_FORMAT_MESSAGES, "_agentic_dev_loop_reasoning_repair", False):
     def _config_gated_reasoning_serializer(self, messages: list) -> list[dict]:
         """The engine-owned reasoning passback serializer (054 D8).
@@ -68,7 +80,7 @@ if not getattr(_ORIGINAL_FORMAT_MESSAGES, "_agentic_dev_loop_reasoning_repair",
                 raise _reasoning_stripped_error(self)
             validate_string_tool_results(
                 messages, out, forced=bool(self.force_string_serializer))
-            return out
+            return _with_billing_prefix(self, out)
 
         last = None
         for msg, d in zip(messages, out):
@@ -87,7 +99,7 @@ if not getattr(_ORIGINAL_FORMAT_MESSAGES, "_agentic_dev_loop_reasoning_repair",
                 d["reasoning_content"] = rc
         validate_string_tool_results(
             messages, out, forced=bool(self.force_string_serializer))
-        return out
+        return _with_billing_prefix(self, out)
 
     _config_gated_reasoning_serializer._agentic_dev_loop_reasoning_repair = True
     LLM.format_messages_for_llm = _config_gated_reasoning_serializer
@@ -161,10 +173,11 @@ def build_llm(cfg: LlmConfig, reasoning_effort: str | None = None) -> LLM:
     # off. reasoning_effort is always passed (None when unset) so the SDK
     # "high" default cannot engage; absent effort = reasoning off.
     effort = reasoning_effort if reasoning_effort is not None else cfg.reasoning_effort
-    # Copilot gateway policy (provider_wire.py): the gateway silently drops
+    # Gateway policy (provider_wire.py): the Copilot gateway silently drops
     # ARRAY-encoded tool-result content, so Copilot-configured instances
-    # force the SDK's documented string content serializer. Every other
-    # gateway keeps the SDK default (None = auto-detect by model registry).
+    # force the SDK's documented string content serializer. The Claude
+    # subscription endpoint keeps the SDK default (None = auto-detect by
+    # model registry) and carries the billing-header system prefix instead.
     adapter = adapter_for(cfg.base_url)
     llm = LLM(
         model=cfg.model,
@@ -178,4 +191,6 @@ def build_llm(cfg: LlmConfig, reasoning_effort: str | None = None) -> LLM:
     llm._agentic_dev_loop_reasoning_effort = effort
     llm._agentic_dev_loop_merge_choices = (
         adapter.merge_choices if adapter else False)
+    llm._agentic_dev_loop_system_prefix = (
+        adapter.system_prefix if adapter else None)
     return llm

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/src/agentic_dev_loop/engine/onboarding/upgrade.py

@@ -43,8 +43,12 @@ def run_upgrade(argv: list[str], *, workspace: Path | None = None,
               "pipx-managed", file=sys.stderr)
         return 1
 
+    # --pre is required: the release process yanks superseded releases, and
+    # the current latest (1.0.0b1) is a pre-release, so a plain install has
+    # no satisfiable version. pipx translates --pre on both backends (pip and
+    # uv); dropping it here breaks upgrade until a stable release ships.
     result = subprocess.run(
-        [pipx, "install", "--force", "agentic-dev-loop"],
+        [pipx, "install", "--force", "--pip-args=--pre", "agentic-dev-loop"],
         capture_output=True, text=True, check=False, env=env)
     if result.returncode != 0:
         detail = (result.stderr or "unknown error").strip()

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/src/agentic_dev_loop/engine/provider_wire.py

@@ -7,8 +7,9 @@ ARRAY-encoded tool-result content (probe-proven 2026-11-06: string tool
 content is answered, array tool content is invisible to the model - see
 aidlc-docs/audit.md). The SDK's own remedy is its documented
 ``force_string_serializer`` field on LLM, so this module is POLICY ONLY:
-which gateway base URL requires which wire shape. ``build_llm`` applies the
-policy to every instance it builds. Nothing is monkeypatched.
+which gateway base URL requires which wire shape, plus the one Claude
+subscription policy (the billing-header system prefix). ``build_llm`` applies
+the policy to every instance it builds. Nothing is monkeypatched.
 """
 
 from __future__ import annotations
@@ -17,20 +18,54 @@ from dataclasses import dataclass
 
 from agentic_dev_loop.engine.copilot_auth import COPILOT_BASE_URL
 
+# The Anthropic subscription endpoint. An llm block points its base_url at
+# this exact value: litellm routes bare claude-* model names through its
+# native Anthropic provider path (Messages API, Bearer auth auto-detected
+# from a ``sk-ant-oat01-`` token), and the adapter keyed below engages.
+# No /v1 suffix: litellm appends /v1/messages to a base URL that does not
+# already end with it (a /v1 value would 404 on /v1/v1/messages).
+CLAUDE_BASE_URL = "https://api.anthropic.com"
+
+# Anthropic's gateway only accepts OAuth-subscription traffic that is shaped
+# like a Claude Code request. The gate is the FIRST system text block: it
+# must carry an ``x-anthropic-billing-header:`` entry, or the endpoint
+# answers 429 rate_limit_error regardless of every other header and body
+# field (probe-proven 2026-11-13 against the live endpoint: only the
+# system field moved the replay between 200 and 429). The field values are
+# unvalidated with one exception, cc_version: models that require a newer
+# Claude Code are refused with claude_code_version_too_old, so pin the
+# current CLI version and bump it when the gateway demands newer.
+CLAUDE_BILLING_HEADER = (
+    "x-anthropic-billing-header: cc_version=2.1.323.c04; "
+    "cc_entrypoint=sdk-cli; cc_turn_origin=cli;"
+)
+
 
 @dataclass(frozen=True)
 class WireAdapter:
-    """The wire shape a gateway requires for message content."""
+    """Provider policy ``build_llm`` applies to every instance it builds.
+
+    ``system_prefix`` (Claude subscription): a system message prepended
+    ahead of the pipeline's real system prompt on every outgoing request."""
 
     name: str
     force_string_serializer: bool
     merge_choices: bool = False
+    system_prefix: str | None = None
 
 
 copilot_strings = WireAdapter(name="copilot-strings", force_string_serializer=True,
                               merge_choices=True)
 
-WIRE_ADAPTERS: dict[str, WireAdapter] = {COPILOT_BASE_URL: copilot_strings}
+claude_subscription = WireAdapter(name="claude-subscription",
+                                  force_string_serializer=False,
+                                  merge_choices=False,
+                                  system_prefix=CLAUDE_BILLING_HEADER)
+
+WIRE_ADAPTERS: dict[str, WireAdapter] = {
+    COPILOT_BASE_URL: copilot_strings,
+    CLAUDE_BASE_URL: claude_subscription,
+}
 
 
 def adapter_for(base_url: str | None) -> WireAdapter | None:
@@ -44,6 +79,8 @@ def provider_name(base_url: str | None) -> str:
     """Display name of the LLM provider behind a base URL."""
     if base_url is not None and base_url.rstrip("/") == COPILOT_BASE_URL:
         return "Copilot"
+    if base_url is not None and base_url.rstrip("/") == CLAUDE_BASE_URL:
+        return "Claude"
     return "OpenAI"
 
 

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/src/agentic_dev_loop/engine/run_status_command.md

@@ -20,4 +20,4 @@ The command prints two sections: `===MERMAID===` then `===SUMMARY===`.
 
 ## Errors
 
-- If `agentic-dev-loop` is not on PATH, report that the engine is not installed (`pipx install agentic-dev-loop`) and stop.
+- If `agentic-dev-loop` is not on PATH, report that the engine is not installed (`pipx install --pip-args="--pre" agentic-dev-loop`) and stop.

{agentic_dev_loop-1.0.0b1 → agentic_dev_loop-1.0.0rc3}/src/agentic_dev_loop/engine/secrets.py

@@ -77,13 +77,15 @@ class FileProvider:
         if not path.is_file():
             raise SecretResolutionError(
                 f"secret file not found: {path} - run "
-                "`agentic-dev-loop copilot-login` to create it")
+                "`agentic-dev-loop copilot-login` (Copilot) or "
+                "`agentic-dev-loop claude-login` (Claude) to create it")
         try:
             text = path.read_text(encoding="utf-8")
         except OSError as e:
             raise SecretResolutionError(
-                f"secret file unreadable: {path}: {e} - run "
-                "`agentic-dev-loop copilot-login` to recreate it") from e
+                f"secret file unreadable: {path}: {e} - run the matching "
+                "login subcommand (`agentic-dev-loop copilot-login` or "
+                "`agentic-dev-loop claude-login`) to recreate it") from e
         if json_key is None:
             return text.strip()
         try: