agentic-dev-loop 1.0.0a45__tar.gz → 1.0.0a48__tar.gz

{agentic_dev_loop-1.0.0a45/src/agentic_dev_loop.egg-info → agentic_dev_loop-1.0.0a48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a45
+Version: 1.0.0a48
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -199,6 +199,7 @@ llm:
   model: openai/deepseek-v4-pro
   base_url: https://api.deepseek.com
   api_key_env: OPENAI_API_KEY
+  # reasoning_effort: medium                        # optional: low | medium | high | xhigh | none
 
 max_attempts: 10                                        # CLI --max-attempts overrides
 agents_dir: sdk_agents                                  # your <name>.agent.md files
@@ -228,6 +229,7 @@ steps:
     agent: review
     artifact: review-findings.md
     verdicts: { pass: APPROVED, fail: NEEDS CHANGES }
+    # reasoning_effort: xhigh                        # per-step override; falls back to the llm block, then SDK default
     on_pass: qa
     on_fail: { goto: dev, retry: true }
 
@@ -253,6 +255,7 @@ steps:
 | `terminal_timeout:` | Optional agent-step per-action timeout in seconds (gt 0). `SandboxTerminalExecutor` uses it when the agent leaves the terminal action timeout unset, overriding the SDK tool's default. `None` = current behavior. |
 | `finalize_nudge_turns:` | Optional agent-step final-response nudge (gt 0). Requires `max_iterations:` and must be less than it. At `max_iterations - finalize_nudge_turns` completed turns the engine injects one advisory turn ("`N turns remain: produce your final response now`"), exactly once; the agent may still exhaust its turns and existing stuck/unclear handling applies unchanged. Absent = current behavior. Provisional pending one consumer run (revert if noisy or the raised cap inflates cost). |
 | `custom_prompt:` | Planned (planning-docs/040). Optional agent-step value: literal text, or a path whose file contents are read at load time, appended verbatim to the agent prompt at context assembly (after the prompt, before the task/artifacts). A value that looks like a path but names no file is a validation error. Agent steps only. |
+| `reasoning_effort:` | Optional `low` / `medium` / `high` / `xhigh` / `none`. Set on the `llm` block (pipeline-global) or per-step (overrides the block). Unset anywhere = the field is not passed and the SDK default (`high`) applies, so today's behavior is unchanged. Forwarded only for models the SDK/LiteLLM mark as supporting it; an unsupported value fails at the first LLM call. See [Reasoning effort](#reasoning-effort-opt-in). |
 | `on_pass:` / `on_fail:` | A step name, terminal `success`/`failure`, or `{goto: X, retry: true}`. No loops happen unless you write them. |
 | `env:` / `setup:` / `network:` | `env:` declares step vars (fixed safe base + declared vars only); `setup:` provisions the sandbox before the step runs (command or agent steps; network ON; stamp-cached, re-runs when the pipeline's lockfiles change); `network: true` lets a command/agent step reach the hosts its `egress:` allowlist names (default off) - see [Per-stage networking](#per-stage-networking). |
 | `setup_probe:` | Optional consumer-authored in-container probe run on a warm `setup:` stamp instead of the venv probe. Exit 0 trusts the stamp (skips); any nonzero re-provisions with network on (fail toward freshness). The probe text is NOT part of the stamp key, so a probe-only change needs `--refresh` or `--clean-stamps` to take effect. Example (asserting a warmed esbuild binary is Linux-shaped): `file frontend-editor/node_modules/esbuild/bin/esbuild | grep -q ELF`. |
@@ -266,6 +269,30 @@ steps:
 | `caches:` / `sync_excludes:` | Top-level run-wide lists. `caches:` names repo-relative toolchain cache dirs bind-mounted rw from the real workspace (auto-created if missing); a `setup:` hook can warm them (the provision container carries the same cache mounts); `sync_excludes:` names scratch paths skipped from both the export copy and sync-back (wildcard `*` spans separators, so `**/bin/**` matches a `/bin/` segment at any depth). Both default to `[]`. See [docs/setup.md](docs/setup.md). |
 | `merge_on_conflict:` | Top-level run-wide list of append-style logs (same path vocabulary as `sync_excludes:`, default `[]`). A concurrent host edit to a listed path is union-merged instead of raising: the host file wins and the sandbox's export-only lines are appended in order; both sides converge and the run continues. See [docs/setup.md](docs/setup.md). |
 
+### Reasoning effort (opt-in)
+
+`reasoning_effort` is an opt-in latency dial on the pipeline `llm` block and
+on individual agent steps. It takes one of `low`, `medium`, `high`, `xhigh`,
+or `none`; unset means the field is never passed and the SDK default
+(`high`) applies, so a pipeline that omits it behaves exactly as before. A
+step's value overrides the `llm` block's value, so the review lane can hold
+a higher effort than the rest.
+
+The value is forwarded only for models the SDK/LiteLLM mark as supporting
+it; an unsupported value fails at the first LLM call (the schema rejects
+unknown names at load time, but cannot know provider capability). No
+pipeline ships a value: adopt one only after an observed run proves lower
+per-turn latency with a green suite and no provider 400s.
+
+Recommended lane defaults (guidance only, not enforced):
+
+| Lane | reasoning_effort | Why |
+| --- | --- | --- |
+| brief | medium | digest and classify, no design work |
+| dev | high | hold the line: dev caught a real plan bug and a real sandbox triage this unit |
+| qa | medium | classification discipline must stay reliable |
+| review | xhigh | shortest lane, highest stakes: a missed detection sails past the last gate into commit |
+
 A `brief_inputs:` step is the per-run context-digestion pattern: it runs once at
 run start (or when its inputs change), its `produces:` artifact survives attempt
 starts, and the dev/review agents read that digest instead of re-deriving repo
@@ -357,10 +384,11 @@ steps:
   structurally enforced.** A networked step runs on a per-run internal
   docker network with no route to the host. Its traffic is forced
   through a containerized egress proxy (injected via
-  `HTTP_PROXY`/`HTTPS_PROXY`, pointed at the proxy container's DNS name
-  on the internal network); a request to an undeclared host is denied
-  and logged as an enforcement event. The engine never adds an
-  undeclared target. `egress: { class: browser }` is the explicit
+  `HTTP_PROXY`/`HTTPS_PROXY`, pointed at the proxy's internal IP
+  on the internal network; each distinct egress policy gets its own
+  proxy with a distinct internal IP); a request to an undeclared host
+  is denied and logged as an enforcement event. The engine never adds
+  an undeclared target. `egress: { class: browser }` is the explicit
   broad-but-logged class (every connection logged, nothing filtered); command
   and agent steps default to a strict allowlist.
 - **Command, agent, and sandbox-action steps** may declare it. The host-side

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a48}/README.md

@@ -155,6 +155,7 @@ llm:
   model: openai/deepseek-v4-pro
   base_url: https://api.deepseek.com
   api_key_env: OPENAI_API_KEY
+  # reasoning_effort: medium                        # optional: low | medium | high | xhigh | none
 
 max_attempts: 10                                        # CLI --max-attempts overrides
 agents_dir: sdk_agents                                  # your <name>.agent.md files
@@ -184,6 +185,7 @@ steps:
     agent: review
     artifact: review-findings.md
     verdicts: { pass: APPROVED, fail: NEEDS CHANGES }
+    # reasoning_effort: xhigh                        # per-step override; falls back to the llm block, then SDK default
     on_pass: qa
     on_fail: { goto: dev, retry: true }
 
@@ -209,6 +211,7 @@ steps:
 | `terminal_timeout:` | Optional agent-step per-action timeout in seconds (gt 0). `SandboxTerminalExecutor` uses it when the agent leaves the terminal action timeout unset, overriding the SDK tool's default. `None` = current behavior. |
 | `finalize_nudge_turns:` | Optional agent-step final-response nudge (gt 0). Requires `max_iterations:` and must be less than it. At `max_iterations - finalize_nudge_turns` completed turns the engine injects one advisory turn ("`N turns remain: produce your final response now`"), exactly once; the agent may still exhaust its turns and existing stuck/unclear handling applies unchanged. Absent = current behavior. Provisional pending one consumer run (revert if noisy or the raised cap inflates cost). |
 | `custom_prompt:` | Planned (planning-docs/040). Optional agent-step value: literal text, or a path whose file contents are read at load time, appended verbatim to the agent prompt at context assembly (after the prompt, before the task/artifacts). A value that looks like a path but names no file is a validation error. Agent steps only. |
+| `reasoning_effort:` | Optional `low` / `medium` / `high` / `xhigh` / `none`. Set on the `llm` block (pipeline-global) or per-step (overrides the block). Unset anywhere = the field is not passed and the SDK default (`high`) applies, so today's behavior is unchanged. Forwarded only for models the SDK/LiteLLM mark as supporting it; an unsupported value fails at the first LLM call. See [Reasoning effort](#reasoning-effort-opt-in). |
 | `on_pass:` / `on_fail:` | A step name, terminal `success`/`failure`, or `{goto: X, retry: true}`. No loops happen unless you write them. |
 | `env:` / `setup:` / `network:` | `env:` declares step vars (fixed safe base + declared vars only); `setup:` provisions the sandbox before the step runs (command or agent steps; network ON; stamp-cached, re-runs when the pipeline's lockfiles change); `network: true` lets a command/agent step reach the hosts its `egress:` allowlist names (default off) - see [Per-stage networking](#per-stage-networking). |
 | `setup_probe:` | Optional consumer-authored in-container probe run on a warm `setup:` stamp instead of the venv probe. Exit 0 trusts the stamp (skips); any nonzero re-provisions with network on (fail toward freshness). The probe text is NOT part of the stamp key, so a probe-only change needs `--refresh` or `--clean-stamps` to take effect. Example (asserting a warmed esbuild binary is Linux-shaped): `file frontend-editor/node_modules/esbuild/bin/esbuild | grep -q ELF`. |
@@ -222,6 +225,30 @@ steps:
 | `caches:` / `sync_excludes:` | Top-level run-wide lists. `caches:` names repo-relative toolchain cache dirs bind-mounted rw from the real workspace (auto-created if missing); a `setup:` hook can warm them (the provision container carries the same cache mounts); `sync_excludes:` names scratch paths skipped from both the export copy and sync-back (wildcard `*` spans separators, so `**/bin/**` matches a `/bin/` segment at any depth). Both default to `[]`. See [docs/setup.md](docs/setup.md). |
 | `merge_on_conflict:` | Top-level run-wide list of append-style logs (same path vocabulary as `sync_excludes:`, default `[]`). A concurrent host edit to a listed path is union-merged instead of raising: the host file wins and the sandbox's export-only lines are appended in order; both sides converge and the run continues. See [docs/setup.md](docs/setup.md). |
 
+### Reasoning effort (opt-in)
+
+`reasoning_effort` is an opt-in latency dial on the pipeline `llm` block and
+on individual agent steps. It takes one of `low`, `medium`, `high`, `xhigh`,
+or `none`; unset means the field is never passed and the SDK default
+(`high`) applies, so a pipeline that omits it behaves exactly as before. A
+step's value overrides the `llm` block's value, so the review lane can hold
+a higher effort than the rest.
+
+The value is forwarded only for models the SDK/LiteLLM mark as supporting
+it; an unsupported value fails at the first LLM call (the schema rejects
+unknown names at load time, but cannot know provider capability). No
+pipeline ships a value: adopt one only after an observed run proves lower
+per-turn latency with a green suite and no provider 400s.
+
+Recommended lane defaults (guidance only, not enforced):
+
+| Lane | reasoning_effort | Why |
+| --- | --- | --- |
+| brief | medium | digest and classify, no design work |
+| dev | high | hold the line: dev caught a real plan bug and a real sandbox triage this unit |
+| qa | medium | classification discipline must stay reliable |
+| review | xhigh | shortest lane, highest stakes: a missed detection sails past the last gate into commit |
+
 A `brief_inputs:` step is the per-run context-digestion pattern: it runs once at
 run start (or when its inputs change), its `produces:` artifact survives attempt
 starts, and the dev/review agents read that digest instead of re-deriving repo
@@ -313,10 +340,11 @@ steps:
   structurally enforced.** A networked step runs on a per-run internal
   docker network with no route to the host. Its traffic is forced
   through a containerized egress proxy (injected via
-  `HTTP_PROXY`/`HTTPS_PROXY`, pointed at the proxy container's DNS name
-  on the internal network); a request to an undeclared host is denied
-  and logged as an enforcement event. The engine never adds an
-  undeclared target. `egress: { class: browser }` is the explicit
+  `HTTP_PROXY`/`HTTPS_PROXY`, pointed at the proxy's internal IP
+  on the internal network; each distinct egress policy gets its own
+  proxy with a distinct internal IP); a request to an undeclared host
+  is denied and logged as an enforcement event. The engine never adds
+  an undeclared target. `egress: { class: browser }` is the explicit
   broad-but-logged class (every connection logged, nothing filtered); command
   and agent steps default to a strict allowlist.
 - **Command, agent, and sandbox-action steps** may declare it. The host-side

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a48}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a45"
+version = "1.0.0a48"
 description = "Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase."
 readme = "README.md"
 requires-python = ">=3.12"

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a48}/src/agentic_dev_loop/core/config.py

@@ -6,7 +6,7 @@ import hashlib
 import re
 import warnings
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 import yaml
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
@@ -35,6 +35,11 @@ DEFAULT_BRIEF_SECTIONS = [
     "Open risks",
 ]
 
+# 047: the full SDK reasoning_effort literal, passed through verbatim. The
+# engine is provider-generic, so it validates shape only - whether a given
+# provider accepts every value (notably "none") is operator risk (D3).
+ReasoningEffort = Literal["low", "medium", "high", "xhigh", "none"]
+
 
 def _validate_mount_path(path: str) -> str:
     """Validate one repo-relative mount path (BR-1.3).
@@ -385,6 +390,9 @@ class StepConfig(BaseModel):
     terminal_timeout: float | None = Field(default=None, gt=0)  # seconds, agent steps only (032)
     finalize_nudge_turns: int | None = Field(default=None, gt=0)  # agent steps only (035)
     brief_inputs: BriefInputsSpec | None = None  # agent steps only (033)
+    # 047 (D7): per-step opt-in override; unset falls back to the llm block,
+    # then the SDK default. Full SDK literal, passthrough semantics.
+    reasoning_effort: ReasoningEffort | None = None
     custom_prompt: str | None = None  # agent steps only (040); file path resolved at load
     env: dict[str, str | None] | None = None  # NFR-1: null = inherit host value
     setup: str | None = None  # BR-13: command steps only
@@ -552,6 +560,10 @@ class LlmConfig(BaseModel):
     base_url: str | None = None
     api_key_env: str
     timeout: float | None = None  # omitted → opinionated no-timeout default
+    # 047 (D1): opt-in passthrough; unset means the field is not passed at
+    # all, so the SDK default ("high") applies and today's behavior is
+    # byte-identical. No default may move without an observed run (D6).
+    reasoning_effort: ReasoningEffort | None = None
 
 
 class PipelineConfig(BaseModel):

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a48}/src/agentic_dev_loop/engine/isolation.py

@@ -31,7 +31,7 @@ import sys
 import time
 import uuid
 from abc import ABC, abstractmethod
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
@@ -299,10 +299,10 @@ def proxy_container_name(run_id: str, profile_key: str) -> str:
     return f"{run_id}-proxy-{profile_key}"
 
 
-def proxy_url(proxy_name: str, port: int = EGRESS_PROXY_PORT) -> str:
-    """The sandbox-reachable proxy URL: the proxy container's internal DNS
-    name on the internal network (038, D3). Never 127.0.0.1 or the host-gateway."""
-    return f"http://{proxy_name}:{port}"
+def proxy_url(proxy_host: str, port: int = EGRESS_PROXY_PORT) -> str:
+    """The sandbox-reachable proxy URL: the proxy's internal address on the
+    internal network (038, D3). Never 127.0.0.1 or the host-gateway."""
+    return f"http://{proxy_host}:{port}"
 
 
 def egress_events_path(iso_state_dir: str | Path, run_id: str) -> Path:
@@ -310,8 +310,10 @@ def egress_events_path(iso_state_dir: str | Path, run_id: str) -> Path:
     return Path(iso_state_dir) / f"{EGRESS_EVENTS_PREFIX}-{run_id}.jsonl"
 
 
-def first_usable_ip(subnets: str) -> str | None:
-    """First usable non-gateway IPv4 address from one or more CIDR subnets."""
+def proxy_usable_ips(subnets: str) -> list[str]:
+    """Usable non-gateway IPv4 host addresses from the first viable subnet
+    (048 D1): ``hosts[1:]``, skipping the gateway at ``hosts[0]``. Empty when
+    no subnet offers a non-gateway host."""
     for token in subnets.split():
         try:
             network = ipaddress.ip_network(token, strict=False)
@@ -322,8 +324,8 @@ def first_usable_ip(subnets: str) -> str | None:
         hosts = list(network.hosts())
         if len(hosts) < 2:
             continue
-        return str(hosts[1])
-    return None
+        return [str(host) for host in hosts[1:]]
+    return []
 
 
 
@@ -964,6 +966,7 @@ class DockerBackend(Sandbox):
         self._run_net = run_network_name(self._run_id)
         self._network_created = False
         self._proxy_containers: list[str] = []
+        self._proxy_ips: dict[str, str] = {}
         self._egress_events_path = egress_events_path(self._iso_state_dir,
                                                       self._run_id)
         self._sandbox_venv_dir = sandbox_venv_dir  # 022 relocated venv (opt-in)
@@ -1309,9 +1312,9 @@ class DockerBackend(Sandbox):
         proxy_url_value: str | None = None
         if network and self._export_root is not None:
             proxy_name = proxy_container_name(self._run_id, key[0][:16])
-            self._start_proxy_container(proxy_name, policy,
-                                         self._dial_rewrites)
-            proxy_url_value = proxy_url(proxy_name)
+            proxy_ip = self._start_proxy_container(proxy_name, policy,
+                                                    self._dial_rewrites)
+            proxy_url_value = proxy_url(proxy_ip)
         payload = docker_create_payload(
             run_id=self._run_id, image=self._image, profile=self._profile,
             workspace=self._workspace, network=network,
@@ -1334,7 +1337,7 @@ class DockerBackend(Sandbox):
                                  started=True)
 
     def _start_proxy_container(self, name: str, policy: EgressPolicy,
-                               dial_rewrites: dict[str, str] | None = None) -> None:
+                               dial_rewrites: dict[str, str] | None = None) -> str:
         """Create one containerized proxy (038 D2/D5, 039 D1-D4): host-access
         network at create time with a pinned internal IP, then attach the internal
         network; the proxy binds that address only and is readiness probed from
@@ -1350,7 +1353,7 @@ class DockerBackend(Sandbox):
         policy_json = egress_proxy_module.policy_to_json(policy)
         dial_rewrites = dict(dial_rewrites or {})
         dial_rewrites_json = json.dumps(dial_rewrites, sort_keys=True)
-        bind_host = self._proxy_internal_ip()
+        bind_host = self._proxy_internal_ip(name)
         payload = docker_proxy_payload(
             run_id=self._run_id, image=self._image, name=name,
             policy_json=policy_json, dial_rewrites_json=dial_rewrites_json,
@@ -1379,22 +1382,63 @@ class DockerBackend(Sandbox):
                 f"{bind_host}:{EGRESS_PROXY_PORT} after "
                 f"{PROXY_READY_ATTEMPTS} readiness probes")
         self._proxy_containers.append(name)
-
-    def _proxy_internal_ip(self) -> str:
-        """Return the pinned first-usable IPv4 address on the internal network."""
+        return bind_host
+
+    def _proxy_internal_ip(self, proxy_name: str) -> str:
+        """Return the per-proxy pinned IPv4 address on the internal network
+        (048 D1): inspect the subnet and the addresses containers already hold
+        on it, then allocate the next free host (profile containers join the
+        run network with a daemon auto-assigned IP, so those must be skipped
+        or the later ``network connect --ip`` collides)."""
         inspect = self._runner.run(
             ["docker", "network", "inspect", "-f",
-             "{{range .IPAM.Config}}{{.Subnet}} {{end}}", self._run_net],
+             "{{range .IPAM.Config}}{{.Subnet}} {{end}}|"
+             "{{range .Containers}}{{.IPv4Address}} {{end}}",
+             self._run_net],
             timeout=30)
         if inspect.exit_code != 0:
             raise SandboxError(
                 f"AE-SBX-021: internal network inspect failed: "
                 f"{inspect.stderr.strip() or inspect.stdout.strip()}")
-        ip = first_usable_ip(inspect.stdout)
-        if ip is None:
+        subnets, sep, in_use_part = inspect.stdout.partition("|")
+        in_use = in_use_part.split() if sep else ()
+        return self._allocate_proxy_ip(subnets, proxy_name, in_use)
+
+    def _allocate_proxy_ip(self, subnets: str, proxy_name: str,
+                           in_use: Iterable[str] = ()) -> str:
+        """Allocate one internal IPv4 address per proxy (048 D1/D2). An
+        existing allocation for ``proxy_name`` is reused; otherwise the first
+        free non-gateway host wins (the first proxy keeps ``hosts[1]``).
+        Addresses in ``in_use`` (held by other containers on the network) are
+        skipped alongside the already-allocated proxy IPs. Raises when the
+        subnet has no free host instead of letting the daemon emit a
+        confusing collision error."""
+        existing = self._proxy_ips.get(proxy_name)
+        if existing is not None:
+            return existing
+        hosts = proxy_usable_ips(subnets)
+        if not hosts:
             raise SandboxError(
                 f"AE-SBX-021: internal network has no usable IPv4 subnet: "
-                f"{inspect.stdout.strip()!r}")
+                f"{subnets.strip()!r}")
+        taken = set(self._proxy_ips.values())
+        for token in in_use:
+            addr = token.split("/", 1)[0].strip()
+            try:
+                ip = ipaddress.ip_address(addr)
+            except ValueError:
+                continue
+            if isinstance(ip, ipaddress.IPv4Address):
+                taken.add(str(ip))
+        free = [host for host in hosts if host not in taken]
+        if not free:
+            raise SandboxError(
+                f"AE-SBX-021: internal network {subnets.strip()!r} has "
+                f"{len(hosts)} usable proxy address(es) but "
+                f"{len(self._proxy_ips) + 1} egress proxies were requested - "
+                f"no free address to assign")
+        ip = free[0]
+        self._proxy_ips[proxy_name] = ip
         return ip
 
     def _wait_proxy_ready(self, name: str, host: str) -> bool:
@@ -1541,6 +1585,7 @@ class DockerBackend(Sandbox):
         for name in self._proxy_containers:
             self._rm_container(name)
         self._proxy_containers.clear()
+        self._proxy_ips.clear()
         if self._network_created:
             self._runner.run(["docker", "network", "rm", self._run_net], timeout=60)
             self._network_created = False

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a48}/src/agentic_dev_loop/engine/llm.py

@@ -48,13 +48,20 @@ if not getattr(_ORIGINAL_FORMAT_MESSAGES, "_agentic_dev_loop_reasoning_repair",
     LLM.format_messages_for_llm = _repair_reasoning_passback
 
 
-def build_llm(cfg: LlmConfig) -> LLM:
+def build_llm(cfg: LlmConfig, reasoning_effort: str | None = None) -> LLM:
     api_key = os.environ.get(cfg.api_key_env)
     if not api_key:
         raise RuntimeError(f"{cfg.api_key_env} environment variable is required")
-    return LLM(
-        model=cfg.model,
-        api_key=api_key,
-        base_url=cfg.base_url,
-        timeout=cfg.timeout,  # policy: no LLM timeout unless explicitly set
-    )
+    # 047 (D2/D7): an explicit per-step override wins, else the llm block's
+    # value applies, else the field is omitted entirely and the SDK default
+    # ("high") is in force. The reasoning_content shims above stay untouched.
+    effort = reasoning_effort if reasoning_effort is not None else cfg.reasoning_effort
+    kwargs = {
+        "model": cfg.model,
+        "api_key": api_key,
+        "base_url": cfg.base_url,
+        "timeout": cfg.timeout,  # policy: no LLM timeout unless explicitly set
+    }
+    if effort is not None:
+        kwargs["reasoning_effort"] = effort
+    return LLM(**kwargs)

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a48}/src/agentic_dev_loop/engine/stages.py

@@ -42,6 +42,7 @@ from .egress_policy import assemble_egress_policy
 from .forbidden import resolve_forbidden_rules
 from .isolation import (SandboxError, SandboxExecutionRequest, command_argv,
                         resolve_sandbox_env)
+from .llm import build_llm
 from .mounts import resolve_mount_set
 from .outputs import CapturedOutput
 from .secrets import redact_values, step_secret_env
@@ -174,11 +175,18 @@ class Runtime:
                              if step is not None else None),
                     forbidden_commands=forbidden_commands,
                     allowlist=allowlist)
+            # 047 (D7): a step's reasoning_effort overrides the llm block's;
+            # self.llm already carries the block value (or the SDK default),
+            # so only build a fresh LLM when the step overrides it.
+            llm = self.llm
+            if step is not None and step.reasoning_effort is not None:
+                llm = build_llm(self.cfg.llm,
+                                reasoning_effort=step.reasoning_effort)
             if step is not None and step.brief_inputs is not None:
                 agent = load_brief_agent(
-                    agent_name, step.brief_inputs.sections, self.llm)
+                    agent_name, step.brief_inputs.sections, llm)
             else:
-                agent = load_agent(self.agents_dir, agent_name, self.llm)
+                agent = load_agent(self.agents_dir, agent_name, llm)
             callbacks = []
             if finalize_controller is not None:
                 callbacks.append(finalize_controller.on_event)

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a48/src/agentic_dev_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a45
+Version: 1.0.0a48
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -199,6 +199,7 @@ llm:
   model: openai/deepseek-v4-pro
   base_url: https://api.deepseek.com
   api_key_env: OPENAI_API_KEY
+  # reasoning_effort: medium                        # optional: low | medium | high | xhigh | none
 
 max_attempts: 10                                        # CLI --max-attempts overrides
 agents_dir: sdk_agents                                  # your <name>.agent.md files
@@ -228,6 +229,7 @@ steps:
     agent: review
     artifact: review-findings.md
     verdicts: { pass: APPROVED, fail: NEEDS CHANGES }
+    # reasoning_effort: xhigh                        # per-step override; falls back to the llm block, then SDK default
     on_pass: qa
     on_fail: { goto: dev, retry: true }
 
@@ -253,6 +255,7 @@ steps:
 | `terminal_timeout:` | Optional agent-step per-action timeout in seconds (gt 0). `SandboxTerminalExecutor` uses it when the agent leaves the terminal action timeout unset, overriding the SDK tool's default. `None` = current behavior. |
 | `finalize_nudge_turns:` | Optional agent-step final-response nudge (gt 0). Requires `max_iterations:` and must be less than it. At `max_iterations - finalize_nudge_turns` completed turns the engine injects one advisory turn ("`N turns remain: produce your final response now`"), exactly once; the agent may still exhaust its turns and existing stuck/unclear handling applies unchanged. Absent = current behavior. Provisional pending one consumer run (revert if noisy or the raised cap inflates cost). |
 | `custom_prompt:` | Planned (planning-docs/040). Optional agent-step value: literal text, or a path whose file contents are read at load time, appended verbatim to the agent prompt at context assembly (after the prompt, before the task/artifacts). A value that looks like a path but names no file is a validation error. Agent steps only. |
+| `reasoning_effort:` | Optional `low` / `medium` / `high` / `xhigh` / `none`. Set on the `llm` block (pipeline-global) or per-step (overrides the block). Unset anywhere = the field is not passed and the SDK default (`high`) applies, so today's behavior is unchanged. Forwarded only for models the SDK/LiteLLM mark as supporting it; an unsupported value fails at the first LLM call. See [Reasoning effort](#reasoning-effort-opt-in). |
 | `on_pass:` / `on_fail:` | A step name, terminal `success`/`failure`, or `{goto: X, retry: true}`. No loops happen unless you write them. |
 | `env:` / `setup:` / `network:` | `env:` declares step vars (fixed safe base + declared vars only); `setup:` provisions the sandbox before the step runs (command or agent steps; network ON; stamp-cached, re-runs when the pipeline's lockfiles change); `network: true` lets a command/agent step reach the hosts its `egress:` allowlist names (default off) - see [Per-stage networking](#per-stage-networking). |
 | `setup_probe:` | Optional consumer-authored in-container probe run on a warm `setup:` stamp instead of the venv probe. Exit 0 trusts the stamp (skips); any nonzero re-provisions with network on (fail toward freshness). The probe text is NOT part of the stamp key, so a probe-only change needs `--refresh` or `--clean-stamps` to take effect. Example (asserting a warmed esbuild binary is Linux-shaped): `file frontend-editor/node_modules/esbuild/bin/esbuild | grep -q ELF`. |
@@ -266,6 +269,30 @@ steps:
 | `caches:` / `sync_excludes:` | Top-level run-wide lists. `caches:` names repo-relative toolchain cache dirs bind-mounted rw from the real workspace (auto-created if missing); a `setup:` hook can warm them (the provision container carries the same cache mounts); `sync_excludes:` names scratch paths skipped from both the export copy and sync-back (wildcard `*` spans separators, so `**/bin/**` matches a `/bin/` segment at any depth). Both default to `[]`. See [docs/setup.md](docs/setup.md). |
 | `merge_on_conflict:` | Top-level run-wide list of append-style logs (same path vocabulary as `sync_excludes:`, default `[]`). A concurrent host edit to a listed path is union-merged instead of raising: the host file wins and the sandbox's export-only lines are appended in order; both sides converge and the run continues. See [docs/setup.md](docs/setup.md). |
 
+### Reasoning effort (opt-in)
+
+`reasoning_effort` is an opt-in latency dial on the pipeline `llm` block and
+on individual agent steps. It takes one of `low`, `medium`, `high`, `xhigh`,
+or `none`; unset means the field is never passed and the SDK default
+(`high`) applies, so a pipeline that omits it behaves exactly as before. A
+step's value overrides the `llm` block's value, so the review lane can hold
+a higher effort than the rest.
+
+The value is forwarded only for models the SDK/LiteLLM mark as supporting
+it; an unsupported value fails at the first LLM call (the schema rejects
+unknown names at load time, but cannot know provider capability). No
+pipeline ships a value: adopt one only after an observed run proves lower
+per-turn latency with a green suite and no provider 400s.
+
+Recommended lane defaults (guidance only, not enforced):
+
+| Lane | reasoning_effort | Why |
+| --- | --- | --- |
+| brief | medium | digest and classify, no design work |
+| dev | high | hold the line: dev caught a real plan bug and a real sandbox triage this unit |
+| qa | medium | classification discipline must stay reliable |
+| review | xhigh | shortest lane, highest stakes: a missed detection sails past the last gate into commit |
+
 A `brief_inputs:` step is the per-run context-digestion pattern: it runs once at
 run start (or when its inputs change), its `produces:` artifact survives attempt
 starts, and the dev/review agents read that digest instead of re-deriving repo
@@ -357,10 +384,11 @@ steps:
   structurally enforced.** A networked step runs on a per-run internal
   docker network with no route to the host. Its traffic is forced
   through a containerized egress proxy (injected via
-  `HTTP_PROXY`/`HTTPS_PROXY`, pointed at the proxy container's DNS name
-  on the internal network); a request to an undeclared host is denied
-  and logged as an enforcement event. The engine never adds an
-  undeclared target. `egress: { class: browser }` is the explicit
+  `HTTP_PROXY`/`HTTPS_PROXY`, pointed at the proxy's internal IP
+  on the internal network; each distinct egress policy gets its own
+  proxy with a distinct internal IP); a request to an undeclared host
+  is denied and logged as an enforcement event. The engine never adds
+  an undeclared target. `egress: { class: browser }` is the explicit
   broad-but-logged class (every connection logged, nothing filtered); command
   and agent steps default to a strict allowlist.
 - **Command, agent, and sandbox-action steps** may declare it. The host-side

{agentic_dev_loop-1.0.0a45 → agentic_dev_loop-1.0.0a48}/tests/test_config.py

@@ -180,6 +180,40 @@ def test_extra_body_llm_key_rejected(tmp_path):
         _load(tmp_path, data)
 
 
+def test_llm_reasoning_effort_round_trips(tmp_path):
+    data = _base()
+    data["llm"]["reasoning_effort"] = "medium"
+    assert _load(tmp_path, data).llm.reasoning_effort == "medium"
+
+
+def test_llm_reasoning_effort_defaults_none(tmp_path):
+    assert _load(tmp_path, _base()).llm.reasoning_effort is None
+
+
+def test_llm_reasoning_effort_unknown_value_rejected(tmp_path):
+    data = _base()
+    data["llm"]["reasoning_effort"] = "maximum"
+    with pytest.raises(ValidationError):
+        _load(tmp_path, data)
+
+
+def test_step_reasoning_effort_round_trips(tmp_path):
+    data = _base()
+    data["steps"][0]["reasoning_effort"] = "xhigh"
+    assert _load(tmp_path, data).steps[0].reasoning_effort == "xhigh"
+
+
+def test_step_reasoning_effort_defaults_none(tmp_path):
+    assert _load(tmp_path, _base()).steps[0].reasoning_effort is None
+
+
+def test_step_reasoning_effort_unknown_value_rejected(tmp_path):
+    data = _base()
+    data["steps"][0]["reasoning_effort"] = "banana"
+    with pytest.raises(ValidationError):
+        _load(tmp_path, data)
+
+
 def test_unknown_route_key_rejected(tmp_path):
     data = _base()
     data["steps"][0]["on_pass"] = {"goto": "success", "bogus": 1}