agentic-dev-loop 1.0.0a44__tar.gz → 1.0.0a46__tar.gz

{agentic_dev_loop-1.0.0a44/src/agentic_dev_loop.egg-info → agentic_dev_loop-1.0.0a46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a44
+Version: 1.0.0a46
 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 }
 
@@ -249,10 +251,11 @@ steps:
 | --- | --- |
 | `agent:` / `command:` / `action:` | Exactly one per step. Agents live in `agents_dir` as `<name>.agent.md`; commands run sandboxed (mechanical, never an LLM call). `commit` is the sole host-side built-in action; consumer actions are sandbox-executed, command-shaped scripts (see [Host boundary](#host-boundary-security-model)). |
 | `produces:` / `artifact:` + `verdicts:` | Hygiene-tracked outputs vs verdict-parsed routing. The **last** `VERDICT:` line wins; stale artifacts are deleted at each attempt start. |
-| `brief_inputs:` | Optional agent-step input spec: `{ include: [<paths/globs>], env_facts: [<strings>] }`. The engine resolves the include list against the workspace, passes the resolved docs + include contents + env facts as that step's task message, and regenerates the step only when those inputs change. A produces-only agent step such as `brief` is the documented pattern for per-run context digestion. |
+| `brief_inputs:` | Optional agent-step input spec: `{ include: [<paths/globs>], env_facts: [<strings>], sections: [<headings>] }`. The engine resolves the include list against the workspace, passes the resolved docs + include contents + env facts as that step's task message, and regenerates the step only when those inputs change. `sections` is the ordered list of digest headings the brief must emit (default `[Repo rules digest, Unit scope digest, Environment facts, Open risks]`; non-empty and unique). A produces-only agent step such as `brief` is the documented pattern for per-run context digestion. |
 | `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,17 +269,43 @@ 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
 rules and environment facts every attempt.
 
-The brief digest is mechanically coverage-checked: the four section headings
-(`Repo rules digest`, `Unit scope and lane digest`, `Environment facts`, and
-`Open risks`) must appear, every anchor extracted from the `include` files
-(markdown `##` headings, and YAML category names plus `enforcement_levels`)
-must appear on its own line (case-insensitive, whitespace-collapsed, `**`
-decoration allowed), and every `env_facts` entry must appear verbatim. A miss
+The brief digest is mechanically coverage-checked: the configured
+`brief_inputs.sections` headings must each appear on their own line, every
+anchor extracted from the `include` files (markdown `##` headings, and YAML
+category names plus `enforcement_levels`) must appear on its own line
+(case-insensitive, whitespace-collapsed, `**` decoration allowed), and every
+`env_facts` entry must appear verbatim. The section list feeds both the
+engine-embedded brief prompt and the coverage gate, so the two can never
+disagree; a miss
 re-runs the brief agent once per missing set with a `## Coverage retry`
 correction note, bounded to three retries per input set; if the same items are
 still dropped after the cap, the run fails and `last-error.md` names the

{agentic_dev_loop-1.0.0a44 → agentic_dev_loop-1.0.0a46}/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 }
 
@@ -205,10 +207,11 @@ steps:
 | --- | --- |
 | `agent:` / `command:` / `action:` | Exactly one per step. Agents live in `agents_dir` as `<name>.agent.md`; commands run sandboxed (mechanical, never an LLM call). `commit` is the sole host-side built-in action; consumer actions are sandbox-executed, command-shaped scripts (see [Host boundary](#host-boundary-security-model)). |
 | `produces:` / `artifact:` + `verdicts:` | Hygiene-tracked outputs vs verdict-parsed routing. The **last** `VERDICT:` line wins; stale artifacts are deleted at each attempt start. |
-| `brief_inputs:` | Optional agent-step input spec: `{ include: [<paths/globs>], env_facts: [<strings>] }`. The engine resolves the include list against the workspace, passes the resolved docs + include contents + env facts as that step's task message, and regenerates the step only when those inputs change. A produces-only agent step such as `brief` is the documented pattern for per-run context digestion. |
+| `brief_inputs:` | Optional agent-step input spec: `{ include: [<paths/globs>], env_facts: [<strings>], sections: [<headings>] }`. The engine resolves the include list against the workspace, passes the resolved docs + include contents + env facts as that step's task message, and regenerates the step only when those inputs change. `sections` is the ordered list of digest headings the brief must emit (default `[Repo rules digest, Unit scope digest, Environment facts, Open risks]`; non-empty and unique). A produces-only agent step such as `brief` is the documented pattern for per-run context digestion. |
 | `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,17 +225,43 @@ 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
 rules and environment facts every attempt.
 
-The brief digest is mechanically coverage-checked: the four section headings
-(`Repo rules digest`, `Unit scope and lane digest`, `Environment facts`, and
-`Open risks`) must appear, every anchor extracted from the `include` files
-(markdown `##` headings, and YAML category names plus `enforcement_levels`)
-must appear on its own line (case-insensitive, whitespace-collapsed, `**`
-decoration allowed), and every `env_facts` entry must appear verbatim. A miss
+The brief digest is mechanically coverage-checked: the configured
+`brief_inputs.sections` headings must each appear on their own line, every
+anchor extracted from the `include` files (markdown `##` headings, and YAML
+category names plus `enforcement_levels`) must appear on its own line
+(case-insensitive, whitespace-collapsed, `**` decoration allowed), and every
+`env_facts` entry must appear verbatim. The section list feeds both the
+engine-embedded brief prompt and the coverage gate, so the two can never
+disagree; a miss
 re-runs the brief agent once per missing set with a `## Coverage retry`
 correction note, bounded to three retries per input set; if the same items are
 still dropped after the cap, the run fails and `last-error.md` names the

{agentic_dev_loop-1.0.0a44 → agentic_dev_loop-1.0.0a46}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a44"
+version = "1.0.0a46"
 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.0a44 → agentic_dev_loop-1.0.0a46}/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
@@ -25,6 +25,21 @@ HOST_ONLY_MOUNT_DIRS = frozenset({".venv"})
 KNOWN_EGRESS_PRESETS = frozenset({"package-registries"})
 EGRESS_CLASSES = frozenset({"allowlist", "browser"})
 
+# The neutral default section headings a brief step must emit (046). A
+# consumer overrides them via `brief_inputs.sections`; the coverage gate
+# and the embedded brief prompt both render from this list.
+DEFAULT_BRIEF_SECTIONS = [
+    "Repo rules digest",
+    "Unit scope digest",
+    "Environment facts",
+    "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).
@@ -318,8 +333,9 @@ class BriefInputsSpec(BaseModel):
 
     include: list[str] = []
     env_facts: list[str] = []
+    sections: list[str] = DEFAULT_BRIEF_SECTIONS
 
-    @field_validator("include", "env_facts", mode="before")
+    @field_validator("include", "env_facts", "sections", mode="before")
     @classmethod
     def _coerce_list(cls, v: Any) -> Any:
         return [v] if isinstance(v, str) else v
@@ -338,6 +354,21 @@ class BriefInputsSpec(BaseModel):
                     "brief_inputs.env_facts entries must be non-empty strings")
         return v
 
+    @field_validator("sections")
+    @classmethod
+    def _valid_sections(cls, v: list[str]) -> list[str]:
+        for section in v:
+            if not isinstance(section, str) or not section.strip():
+                raise ValueError(
+                    "brief_inputs.sections entries must be non-empty strings")
+        if not v:
+            raise ValueError(
+                "brief_inputs.sections must be a non-empty list of headings")
+        if len(set(v)) != len(v):
+            raise ValueError(
+                "brief_inputs.sections entries must be unique")
+        return v
+
 
 class StepConfig(BaseModel):
     """One pipeline step. Its type IS the key it carries: exactly one of
@@ -359,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
@@ -526,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.0a44 → agentic_dev_loop-1.0.0a46}/src/agentic_dev_loop/engine/agents.py

@@ -16,6 +16,7 @@ from openhands.tools.task_tracker import TaskTrackerTool  # noqa: F401 - registe
 from openhands.tools.terminal import TerminalTool  # noqa: F401 - registers "terminal"
 
 from .forbidden import ForbiddenRule, match_forbidden_command
+from .brief_prompt import render_brief_prompt
 from .isolation import (SandboxError, SandboxExecutionRequest, command_argv,
                         resolve_sandbox_env)
 
@@ -59,6 +60,24 @@ def load_agent(agents_dir: Path | str, name: str, llm: LLM) -> "Agent":
     return agent_definition_to_factory(agent_def)(llm)
 
 
+def load_brief_agent(name: str, sections: list[str], llm: LLM) -> "Agent":
+    """Build the brief agent from the engine-embedded prompt (046).
+
+    The brief prompt is engine-owned and versioned; it is never loaded from
+    ``agents_dir``. The OUTPUT contract's headings are rendered from the
+    configured ``brief_inputs.sections``, so the prompt and the coverage gate
+    share one list and cannot diverge (043)."""
+    from openhands.sdk.subagent.registry import agent_definition_to_factory
+    from openhands.sdk.subagent.schema import AgentDefinition
+
+    agent_def = AgentDefinition(
+        name=name,
+        tools=["terminal"],
+        system_prompt=render_brief_prompt(sections),
+    )
+    return agent_definition_to_factory(agent_def)(llm)
+
+
 class SandboxTerminalExecutor(ToolExecutor):
     """A stateless terminal executor: each action is a fresh ``Sandbox.run``
     (no persistent shell session). ``is_input`` degrades to an unsupported

{agentic_dev_loop-1.0.0a44 → agentic_dev_loop-1.0.0a46}/src/agentic_dev_loop/engine/brief_coverage.py

@@ -12,13 +12,6 @@ from __future__ import annotations
 
 import re
 
-_REQUIRED_SECTIONS = (
-    "Repo rules digest",
-    "Unit scope and lane digest",
-    "Environment facts",
-    "Open risks",
-)
-
 
 def _normalize(text: str) -> str:
     """Case-fold and collapse whitespace - the matching normal form."""
@@ -38,11 +31,6 @@ def _normalize_line(line: str) -> str:
     return _normalize(stripped)
 
 
-def required_sections() -> list[str]:
-    """The four template headings the brief must emit."""
-    return list(_REQUIRED_SECTIONS)
-
-
 def extract_anchors(content: str) -> list[str]:
     """Derive the mechanical anchor set from one include file.
 
@@ -75,16 +63,17 @@ def extract_anchors(content: str) -> list[str]:
 
 
 def missing_anchors(brief_text: str, anchors: list[str],
-                    env_facts: list[str]) -> list[str]:
+                    env_facts: list[str], sections: list[str]) -> list[str]:
     """Return every required item the captured brief fails to cover.
 
-    Required section headings and anchors are matched line-anchored
-    (case-insensitive, whitespace-collapsed, ``**`` decoration stripped). Env
-    facts are matched verbatim, exactly as handed to the brief agent. An empty
-    list means the digest passes coverage."""
+    Required section headings (from the configured ``brief_inputs.sections``)
+    and anchors are matched line-anchored (case-insensitive,
+    whitespace-collapsed, ``**`` decoration stripped). Env facts are matched
+    verbatim, exactly as handed to the brief agent. An empty list means the
+    digest passes coverage."""
     missing: list[str] = []
     lines = {_normalize_line(line) for line in brief_text.splitlines()}
-    for section in _REQUIRED_SECTIONS:
+    for section in sections:
         if _normalize(section) not in lines:
             missing.append(section)
     for anchor in anchors:

agentic_dev_loop-1.0.0a46/src/agentic_dev_loop/engine/brief_prompt.md

@@ -0,0 +1,46 @@
+# Brief Agent
+
+You are the per-run context digester for a gated construction loop. You run
+once per run (or once when the inputs change) and turn a closed input set into
+a compact brief that the dev and review agents reuse on every attempt.
+
+## WORKFLOW
+
+1. Read every input section in the task message below. The inputs are the
+   resolved unit/plan docs, the listed repo-rule files, and the
+   `Environment facts` block. That is the closed list - nothing else.
+2. Digest the inputs into the configured sections named in OUTPUT below.
+   Digest, do not transcribe: the brief is compact working memory, not a copy
+   of the inputs.
+3. State the brief in your final response. The pipeline captures it as
+   `attempt-brief.md`.
+
+## RULES
+
+- One pass, no exploration. Read the listed inputs, emit the brief, finish.
+  Do not explore, do not verify, do not run commands, and do not read anything
+  not listed in the task message. Your inputs are already embedded in the task
+  message; the terminal is available only if a listed input must be re-read.
+- Prior verdicts and feedback are deliberately absent from your inputs. They
+  reach the dev and review agents through a separate notes channel every
+  attempt. Do not invent them and do not re-derive them.
+- The repo-rules digest is structural: one line per top-level section of each
+  repo-rule input. Markdown anchors are the `##` headings: keep each heading
+  verbatim, then compress that section's rules into the one line that follows
+  it. YAML anchors are each `- name:` entry under `categories:` plus the
+  `enforcement_levels` preamble: keep each name verbatim. No top-level section
+  or category may be dropped; merging is allowed only between a section and
+  its own subsections. The anchor line holds the heading and nothing else; the
+  compressed rules go on the following line:
+
+  - general_principles
+    Simplest thing that works; defer decisions to the last responsible moment.
+
+  A line like `general_principles: Simplest thing that works; ...` does not
+  satisfy coverage; the heading must be the only text on its line.
+- Keep the environment-facts entries verbatim: each fact and the behavior it
+  implies travel together.
+- ASCII only. Do not use em dash characters.
+- If the task message carries a `## Coverage retry` section, regenerate the
+  brief so every listed item appears, verbatim where the contract requires
+  verbatim. No exploration: the listed items are the only correction signal.

agentic_dev_loop-1.0.0a46/src/agentic_dev_loop/engine/brief_prompt.py

@@ -0,0 +1,47 @@
+"""Bundled brief-agent prompt (046).
+
+The brief prompt is an engine-owned resource, versioned with the engine so the
+prompt contract and the coverage gate cannot drift (the 043 divergence class).
+The static prose is packaged and read at runtime like the 034 error guide; the
+section-dependent OUTPUT block is rendered here from the configured
+``brief_inputs.sections`` list, so one list feeds the prompt and the gate.
+
+``BRIEF_PROMPT_VERSION`` joins the brief digest hash: an engine upgrade (or a
+sections edit) busts a cached digest and forces a fresh capture.
+"""
+
+from __future__ import annotations
+
+from importlib.resources import files
+
+BRIEF_PROMPT_RESOURCE = "brief_prompt.md"
+BRIEF_PROMPT_VERSION = "1"
+
+
+def load_template() -> str:
+    """The static brief-prompt prose (header, workflow, rules)."""
+    return (files("agentic_dev_loop.engine")
+            .joinpath(BRIEF_PROMPT_RESOURCE)
+            .read_text(encoding="utf-8"))
+
+
+def _output_block(sections: list[str]) -> str:
+    """Render the OUTPUT contract from the configured section headings."""
+    headings = "\n\n".join(f"## {section}" for section in sections)
+    names = ", ".join(f"`## {section}`" for section in sections)
+    return (
+        "## OUTPUT\n\n"
+        "Start your final response with exactly this structure. Each configured "
+        "section heading appears as its own `## ` line, followed by the "
+        "compressed content for that section (write `None` when a section has "
+        "nothing):\n\n"
+        f"{headings}\n\n"
+        f"The section headings must appear exactly as written above: {names}. "
+        "Do not shorten or rename them, and do not merge a section with "
+        "another section."
+    )
+
+
+def render_brief_prompt(sections: list[str]) -> str:
+    """The full brief prompt: static prose plus the section-rendered OUTPUT."""
+    return load_template() + "\n\n" + _output_block(sections)

{agentic_dev_loop-1.0.0a44 → agentic_dev_loop-1.0.0a46}/src/agentic_dev_loop/engine/dryrun.py

@@ -25,12 +25,16 @@ from .secrets import scan_env_files
 
 def _validate_agents(cfg: PipelineConfig, agents_dir: Path) -> None:
     """Every `agent:` step must resolve to an existing file under agents_dir
-    (the same fail-fast `load_agent` enforces at run time)."""
+    (the same fail-fast `load_agent` enforces at run time).
+
+    The brief prompt is engine-embedded (046), so a ``brief_inputs:`` step is
+    exempt from the agents_dir lookup - it never reads a vendored file."""
     for step in cfg.steps:
-        if step.agent is not None:
-            path = agents_dir / f"{step.agent}.agent.md"
-            if not path.is_file():
-                raise FileNotFoundError(f"Agent file not found: {path}")
+        if step.agent is None or step.brief_inputs is not None:
+            continue
+        path = agents_dir / f"{step.agent}.agent.md"
+        if not path.is_file():
+            raise FileNotFoundError(f"Agent file not found: {path}")
 
 
 def _validate_actions(cfg: PipelineConfig, registry: Registry) -> None:

{agentic_dev_loop-1.0.0a44 → agentic_dev_loop-1.0.0a46}/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.0a44 → agentic_dev_loop-1.0.0a46}/src/agentic_dev_loop/engine/stages.py

@@ -32,8 +32,9 @@ from langgraph.graph import END
 from openhands.sdk import Conversation
 
 from .agent_error_guide import guide_section
-from .agents import load_agent, register_sandbox_terminal
+from .agents import load_agent, load_brief_agent, register_sandbox_terminal
 from .brief_coverage import extract_anchors, missing_anchors
+from .brief_prompt import BRIEF_PROMPT_VERSION
 from agentic_dev_loop.core.config import TERMINALS, PipelineConfig, Route, StepConfig, route_target
 from agentic_dev_loop.core.paths import _has_wildcards
 from .deps import extension_message, parse_missing_dependencies, policy_injection
@@ -41,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
@@ -173,7 +175,18 @@ class Runtime:
                              if step is not None else None),
                     forbidden_commands=forbidden_commands,
                     allowlist=allowlist)
-            agent = load_agent(self.agents_dir, agent_name, self.llm)
+            # 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, llm)
+            else:
+                agent = load_agent(self.agents_dir, agent_name, llm)
             callbacks = []
             if finalize_controller is not None:
                 callbacks.append(finalize_controller.on_event)
@@ -543,6 +556,14 @@ def brief_inputs_hash(runtime: Runtime, step: StepConfig,
     brief step, otherwise the existing digest is reused without an LLM call."""
     sections, env_facts = _brief_sections(runtime, step, docs, doc_sources)
     digest = hashlib.sha256()
+    # 046, D6: the embedded prompt version and the configured section headings
+    # join the hash, so an engine upgrade or a sections edit busts the cached
+    # digest and forces a fresh capture.
+    digest.update(BRIEF_PROMPT_VERSION.encode("utf-8"))
+    digest.update(b"\0")
+    for section in step.brief_inputs.sections:
+        digest.update(section.encode("utf-8"))
+        digest.update(b"\0")
     for key in sorted(sections):
         digest.update(key.encode("utf-8"))
         digest.update(b"\0")
@@ -751,6 +772,20 @@ def make_agent_node(runtime: Runtime, step: StepConfig):
     return node
 
 
+def _warn_vendored_brief(runtime: Runtime, step: StepConfig) -> None:
+    """Warn once per load when a vendored brief prompt exists (046, D5).
+
+    The embedded prompt is authoritative, so a leftover
+    ``<agents_dir>/<agent>.agent.md`` for a ``brief_inputs:`` step is ignored;
+    the warning names it without failing the run."""
+    vendored = runtime.agents_dir / f"{step.agent}.agent.md"
+    if vendored.is_file():
+        print(
+            f"[{runtime.cfg.name}] ignoring vendored brief prompt {vendored} - "
+            "the engine-embedded prompt is authoritative",
+            file=sys.stderr, flush=True)
+
+
 def make_brief_node(runtime: Runtime, step: StepConfig):
     """Node closure for a ``brief_inputs:`` agent step (033).
 
@@ -768,6 +803,7 @@ def make_brief_node(runtime: Runtime, step: StepConfig):
     re-runs the agent with a ``## Coverage retry`` correction note. Exhausting
     the budget writes last-error.md and fails the run."""
     captures = step.artifact is not None or bool(step.produces)
+    _warn_vendored_brief(runtime, step)
 
     def node(state: dict) -> dict:
         attempt = state["attempt"]
@@ -780,6 +816,8 @@ def make_brief_node(runtime: Runtime, step: StepConfig):
             anchors = _brief_anchors(runtime, step)
             env_facts = (list(step.brief_inputs.env_facts)
                          if step.brief_inputs is not None else [])
+            sections = (list(step.brief_inputs.sections)
+                        if step.brief_inputs is not None else [])
         except Exception:
             err = redact_values(traceback.format_exc(), runtime.secrets.values())
             print(err[-4000:], file=sys.stderr, flush=True)
@@ -793,7 +831,7 @@ def make_brief_node(runtime: Runtime, step: StepConfig):
         reused = (existing is not None
                   and state.get("brief_hashes", {}).get(step.name) == current_hash)
 
-        if reused and not missing_anchors(existing, anchors, env_facts):
+        if reused and not missing_anchors(existing, anchors, env_facts, sections):
             print(f"[{subject}] {step.name} brief inputs unchanged - reusing.",
                   flush=True)
             merged = {**state["step_verdicts"], step.name: "pass"}
@@ -802,7 +840,7 @@ def make_brief_node(runtime: Runtime, step: StepConfig):
         coverage_note = None
         if reused:
             coverage_note = _coverage_note_text(
-                missing_anchors(existing, anchors, env_facts))
+                missing_anchors(existing, anchors, env_facts, sections))
         message = build_brief_context(runtime, step, state["docs"],
                                       state.get("doc_sources"),
                                       coverage_note=coverage_note)
@@ -824,7 +862,7 @@ def make_brief_node(runtime: Runtime, step: StepConfig):
                                             result.truncated, max_iterations)],
                     "retry_target": _unclear_target(runtime, step)}
 
-        missing = missing_anchors(result.response or "", anchors, env_facts)
+        missing = missing_anchors(result.response or "", anchors, env_facts, sections)
         if missing:
             prev_hash = state.get("brief_hashes", {}).get(step.name)
             retries = (0 if prev_hash != current_hash