agentic-dev-loop 1.0.0a28__tar.gz → 1.0.0a30__tar.gz

{agentic_dev_loop-1.0.0a28/src/agentic_dev_loop.egg-info → agentic_dev_loop-1.0.0a30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a28
+Version: 1.0.0a30
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -192,9 +192,18 @@ max_attempts: 10                                        # CLI --max-attempts ove
 agents_dir: sdk_agents                                  # your <name>.agent.md files
 
 steps:
+  - name: brief
+    agent: brief
+    produces: attempt-brief.md
+    max_iterations: 12
+    brief_inputs: { include: [AGENTS.md, coding-standards-ddd.yaml], env_facts: ["the workspace is an export with no .git; verify with find/ls, never git status"] }
+    on_pass: dev
+
   - name: dev
     agent: dev
     produces: implementation-summary.md
+    terminal_timeout: 900
+    stop_when: { green_command: ".venv-sandbox/bin/python -m pytest tests/ -q", post_green_turns: 2 }
     on_pass: test
 
   - name: test
@@ -227,6 +236,9 @@ 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. |
+| `stop_when:` | Optional agent-step termination: `{ green_command: <argv regex>, post_green_turns: <int, default 2> }`. When the agent's most recent terminal observation matching `green_command` exits 0 and no workspace writes have happened since, the engine injects one nudge turn, allows `post_green_turns` further turns, then closes the conversation. Absent = run to finish. |
+| `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. |
 | `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). |
 | `mounts:` / `egress:` | Per-step workspace isolation. `mounts:` lists `{path, mode}` entries (`rw`/`ro`, default `ro`) and is **strict-by-default** - empty/missing mounts nothing; only declared-rw paths sync back to the repo. `egress:` is `{class, presets, targets}` (`class: browser` = broad-but-logged; otherwise a strict allowlist). See [Per-stage networking](#per-stage-networking) and [docs/setup.md](docs/setup.md). |
@@ -239,6 +251,11 @@ 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). |
 
+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.
+
 ### Secrets (`secrets:`) - refs only, never values
 
 Secret values never belong in the pipeline yaml, the workspace, or `state_dir`.

{agentic_dev_loop-1.0.0a28 → agentic_dev_loop-1.0.0a30}/README.md

@@ -150,9 +150,18 @@ max_attempts: 10                                        # CLI --max-attempts ove
 agents_dir: sdk_agents                                  # your <name>.agent.md files
 
 steps:
+  - name: brief
+    agent: brief
+    produces: attempt-brief.md
+    max_iterations: 12
+    brief_inputs: { include: [AGENTS.md, coding-standards-ddd.yaml], env_facts: ["the workspace is an export with no .git; verify with find/ls, never git status"] }
+    on_pass: dev
+
   - name: dev
     agent: dev
     produces: implementation-summary.md
+    terminal_timeout: 900
+    stop_when: { green_command: ".venv-sandbox/bin/python -m pytest tests/ -q", post_green_turns: 2 }
     on_pass: test
 
   - name: test
@@ -185,6 +194,9 @@ 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. |
+| `stop_when:` | Optional agent-step termination: `{ green_command: <argv regex>, post_green_turns: <int, default 2> }`. When the agent's most recent terminal observation matching `green_command` exits 0 and no workspace writes have happened since, the engine injects one nudge turn, allows `post_green_turns` further turns, then closes the conversation. Absent = run to finish. |
+| `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. |
 | `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). |
 | `mounts:` / `egress:` | Per-step workspace isolation. `mounts:` lists `{path, mode}` entries (`rw`/`ro`, default `ro`) and is **strict-by-default** - empty/missing mounts nothing; only declared-rw paths sync back to the repo. `egress:` is `{class, presets, targets}` (`class: browser` = broad-but-logged; otherwise a strict allowlist). See [Per-stage networking](#per-stage-networking) and [docs/setup.md](docs/setup.md). |
@@ -197,6 +209,11 @@ 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). |
 
+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.
+
 ### Secrets (`secrets:`) - refs only, never values
 
 Secret values never belong in the pipeline yaml, the workspace, or `state_dir`.

{agentic_dev_loop-1.0.0a28 → agentic_dev_loop-1.0.0a30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a28"
+version = "1.0.0a30"
 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.0a28 → agentic_dev_loop-1.0.0a30}/src/agentic_dev_loop/core/__init__.py

@@ -6,7 +6,8 @@ test fails if this package imports engine/viz or heavy deps.
 
 from .config import (PipelineConfig, StepConfig, LlmConfig, IsolationConfig,
                      VerdictSpec, Route, route_target, load_config,
-                     default_state_dir, TERMINALS, MountSpec, EgressSpec)
+                     default_state_dir, TERMINALS, MountSpec, EgressSpec,
+                     StopWhenSpec)
 from .results import Result
 from .verdict import Verdict, VerdictError, parse_verdict, RETRY
 
@@ -14,5 +15,6 @@ __all__ = [
     "PipelineConfig", "StepConfig", "LlmConfig", "IsolationConfig",
     "VerdictSpec", "Route", "route_target", "load_config",
     "default_state_dir", "TERMINALS", "MountSpec", "EgressSpec",
+    "StopWhenSpec",
     "Result", "Verdict", "VerdictError", "parse_verdict", "RETRY",
 ]

{agentic_dev_loop-1.0.0a28 → agentic_dev_loop-1.0.0a30}/src/agentic_dev_loop/core/config.py

@@ -305,6 +305,69 @@ class EgressSpec(BaseModel):
         return [_validate_egress_target(t) for t in v]
 
 
+class StopWhenSpec(BaseModel):
+    """Optional ``stop_when:`` termination signal on an agent step (032).
+
+    ``green_command`` is a regex matched against the agent's terminal
+    observation command; a matching observation that exits 0 - and no
+    workspace writes since - triggers one nudge turn, then
+    ``post_green_turns`` further turns before the engine closes the
+    conversation. Absent ``stop_when`` keeps the current run-to-finish
+    behaviour unchanged.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    green_command: str
+    post_green_turns: int = Field(default=2, ge=0)
+
+    @field_validator("green_command")
+    @classmethod
+    def _valid_regex(cls, v: str) -> str:
+        if not isinstance(v, str) or not v.strip():
+            raise ValueError(
+                "stop_when.green_command must be a non-empty string")
+        try:
+            re.compile(v)
+        except re.error as e:
+            raise ValueError(
+                f"stop_when.green_command is not a valid regex: {e}") from e
+        return v
+
+
+class BriefInputsSpec(BaseModel):
+    """Optional ``brief_inputs:`` on an agent step (033): the closed input
+    list a brief agent digests once per run. ``include`` is repo-relative
+    paths/globs (wildcards allowed); ``env_facts`` are the stable environment
+    facts handed to the agent verbatim so it never discovers them by running
+    commands. Both accept a single string or a list; unknown keys fail at
+    load."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    include: list[str] = []
+    env_facts: list[str] = []
+
+    @field_validator("include", "env_facts", mode="before")
+    @classmethod
+    def _coerce_list(cls, v: Any) -> Any:
+        return [v] if isinstance(v, str) else v
+
+    @field_validator("include")
+    @classmethod
+    def _valid_include(cls, v: list[str]) -> list[str]:
+        return [_validate_declared_path(p, allow_wildcards=True) for p in v]
+
+    @field_validator("env_facts")
+    @classmethod
+    def _valid_env_facts(cls, v: list[str]) -> list[str]:
+        for fact in v:
+            if not isinstance(fact, str) or not fact.strip():
+                raise ValueError(
+                    "brief_inputs.env_facts entries must be non-empty strings")
+        return v
+
+
 class StepConfig(BaseModel):
     """One pipeline step. Its type IS the key it carries: exactly one of
     `agent`, `action`, or `command` - empty values do not count, anything
@@ -322,6 +385,9 @@ class StepConfig(BaseModel):
     verdicts: VerdictSpec | None = None
     max_iterations: int | None = None
     timeout: float | None = Field(default=None, gt=0)  # seconds, command steps only
+    terminal_timeout: float | None = Field(default=None, gt=0)  # seconds, agent steps only (032)
+    stop_when: StopWhenSpec | None = None  # agent steps only (032)
+    brief_inputs: BriefInputsSpec | None = None  # agent steps only (033)
     env: dict[str, str | None] | None = None  # NFR-1: null = inherit host value
     setup: str | None = None  # BR-13: command steps only
     network: bool = False  # per-stage egress (command/agent + sandbox actions; host-side actions reject at registry time)
@@ -386,6 +452,28 @@ class StepConfig(BaseModel):
             raise ValueError(
                 f"step {self.name!r}: 'timeout' requires 'command'"
             )
+        if self.terminal_timeout is not None and self.agent is None:
+            raise ValueError(
+                f"step {self.name!r}: 'terminal_timeout' requires 'agent'"
+            )
+        if self.stop_when is not None and self.agent is None:
+            raise ValueError(
+                f"step {self.name!r}: 'stop_when' requires 'agent'"
+            )
+        if self.brief_inputs is not None and self.agent is None:
+            raise ValueError(
+                f"step {self.name!r}: 'brief_inputs' requires 'agent'"
+            )
+        if (self.brief_inputs is not None
+                and (self.artifact is not None or self.verdicts is not None)):
+            raise ValueError(
+                f"step {self.name!r}: 'brief_inputs' is only valid on a "
+                "produces-only agent step"
+            )
+        if self.brief_inputs is not None and not self.produces:
+            raise ValueError(
+                f"step {self.name!r}: 'brief_inputs' requires 'produces'"
+            )
         if self.setup is not None and self.command is None and self.agent is None:
             raise ValueError(
                 f"step {self.name!r}: 'setup' is only allowed on 'command' or 'agent' steps"

{agentic_dev_loop-1.0.0a28 → agentic_dev_loop-1.0.0a30}/src/agentic_dev_loop/engine/agents.py

@@ -66,7 +66,9 @@ class SandboxTerminalExecutor(ToolExecutor):
     def __init__(self, sandbox: "Sandbox", *, workspace: str = "",
                  env: dict[str, str] | None = None,
                  pipeline: str | None = None, step: str | None = None,
-                 network: bool = False, mount_set=None, egress_policy=None):
+                 network: bool = False, mount_set=None, egress_policy=None,
+                 terminal_timeout: float | None = None,
+                 on_terminal_result=None):
         self._sandbox = sandbox
         self._workspace = workspace
         self._env = env or {}
@@ -75,6 +77,8 @@ class SandboxTerminalExecutor(ToolExecutor):
         self._network = network
         self._mount_set = mount_set
         self._egress_policy = egress_policy
+        self._terminal_timeout = terminal_timeout
+        self._on_terminal_result = on_terminal_result
 
     def __call__(self, action, conversation=None):
         from openhands.tools.terminal import TerminalObservation
@@ -92,9 +96,12 @@ class SandboxTerminalExecutor(ToolExecutor):
                 command=action.command, exit_code=None, timeout=False,
                 metadata=CmdOutputMetadata(exit_code=-1))
 
+        timeout = action.timeout
+        if timeout is None and self._terminal_timeout is not None:
+            timeout = self._terminal_timeout
         request = SandboxExecutionRequest(
             argv=command_argv(action.command), cwd=self._workspace,
-            env=self._env, timeout=action.timeout,
+            env=self._env, timeout=timeout,
             pipeline=self._pipeline, step=self._step, network=self._network,
             mount_set=self._mount_set, egress_policy=self._egress_policy)
         try:
@@ -112,6 +119,9 @@ class SandboxTerminalExecutor(ToolExecutor):
                     ConversationExecutionStatus.STUCK
                 )
             raise
+        if self._on_terminal_result is not None:
+            self._on_terminal_result(
+                action.command, result.exit_code, result.wrote_workspace)
         output = result.stdout + result.stderr
         return TerminalObservation.from_text(
             output, is_error=not result.succeeded and not result.is_timeout,
@@ -130,6 +140,8 @@ def register_sandbox_terminal(sandbox: "Sandbox", *, env: dict[str, str | None]
                               step: str | None = None,
                               network: bool = False,
                               mount_set=None, egress_policy=None,
+                              terminal_timeout: float | None = None,
+                              on_terminal_result=None,
                               secrets: dict[str, str] | None = None) -> None:
     """Per-run re-registration of the `terminal` name (KD-4): a callable
     factory that builds the SDK terminal with a `SandboxTerminalExecutor`.
@@ -147,6 +159,8 @@ def register_sandbox_terminal(sandbox: "Sandbox", *, env: dict[str, str | None]
             executor=SandboxTerminalExecutor(
                 sandbox, workspace=workspace, env=resolved_env,
                 pipeline=pipeline, step=step, network=network,
-                mount_set=mount_set, egress_policy=egress_policy))
+                mount_set=mount_set, egress_policy=egress_policy,
+                terminal_timeout=terminal_timeout,
+                on_terminal_result=on_terminal_result))
 
     register_tool("terminal", factory)

{agentic_dev_loop-1.0.0a28 → agentic_dev_loop-1.0.0a30}/src/agentic_dev_loop/engine/dryrun.py

@@ -17,6 +17,7 @@ from .hostboundary import check_orchestrator_install, check_tooling_integrity
 from .loaders import resolve_docs
 from .isolation import (isolation_state_dir, resolve_effective_profile,
                         resolve_image_ref, resolved_seccomp_profile)
+from .stages import validate_brief_inputs
 from .registry import (Registry, default_registry, load_extensions,
                        validate_action_mounts_egress, validate_action_network)
 from .secrets import scan_env_files
@@ -137,8 +138,10 @@ def dry_run(cfg_path, args, registry: Registry | None = None) -> int:
     _validate_agents(cfg, base / cfg.agents_dir)
     _validate_actions(cfg, registry)
     resolved_seccomp_profile(cfg)  # fails loud on an unknown bundled:<name>
+    for step in cfg.steps:
+        validate_brief_inputs(Path.cwd(), step)
 
-    loader, docs, subject = resolve_docs(cfg, base, registry, args)
+    loader, docs, subject, _doc_sources = resolve_docs(cfg, base, registry, args)
     image, memory, cpus = _resolved_image(cfg)
     state_dir = isolation_state_dir(cfg)
 

{agentic_dev_loop-1.0.0a28 → agentic_dev_loop-1.0.0a30}/src/agentic_dev_loop/engine/extensions/aidlc.py

@@ -21,8 +21,15 @@ from pathlib import Path
 _DOC_SUFFIXES = (".md", ".yaml", ".yml", ".txt")
 
 
-def resolve_unit_docs(docs_dir: Path | str, unit_slug: str) -> dict[str, str]:
+def resolve_unit_docs_with_sources(
+        docs_dir: Path | str, unit_slug: str
+        ) -> tuple[dict[str, str], dict[str, Path]]:
+    """Resolve one AI-DLC unit into (docs, sources). ``docs`` maps each
+    doc's workspace-relative key to its content; ``sources`` maps the same
+    key to its on-disk file so the brief regeneration gate can re-read it
+    (033 D4)."""
     docs: dict[str, str] = {}
+    sources: dict[str, Path] = {}
     docs_dir = Path(docs_dir)
     unit_slug = unit_slug.strip()
 
@@ -47,6 +54,7 @@ def resolve_unit_docs(docs_dir: Path | str, unit_slug: str) -> dict[str, str]:
         if file.is_file() and file.suffix in _DOC_SUFFIXES:
             key = file.relative_to(unit_dir).as_posix()
             docs[key] = file.read_text(encoding="utf-8")
+            sources[key] = file
 
     # At this point docs holds only unit-dir files - an empty load means the
     # pipeline would build context from inception docs alone (the 2026-07-19
@@ -63,6 +71,7 @@ def resolve_unit_docs(docs_dir: Path | str, unit_slug: str) -> dict[str, str]:
         for file in sorted(inception.iterdir()):
             if file.is_file() and file.suffix in (".md", ".txt"):
                 docs[f"inception/{file.name}"] = file.read_text(encoding="utf-8")
+                sources[f"inception/{file.name}"] = file
 
     # The unit's code-generation plans are the build spec - absent is fine,
     # present is how the spec reaches agents.
@@ -70,7 +79,13 @@ def resolve_unit_docs(docs_dir: Path | str, unit_slug: str) -> dict[str, str]:
     if plans_dir.is_dir():
         for file in sorted(plans_dir.glob(f"{unit_slug}-*-code-generation-plan.md")):
             docs[f"plans/{file.name}"] = file.read_text(encoding="utf-8")
+            sources[f"plans/{file.name}"] = file
+
+    return docs, sources
+
 
+def resolve_unit_docs(docs_dir: Path | str, unit_slug: str) -> dict[str, str]:
+    docs, _ = resolve_unit_docs_with_sources(docs_dir, unit_slug)
     return docs
 
 
@@ -116,6 +131,13 @@ class AidlcDocumentLoader:
         unit = args.aidlc_unit or get_current_unit(self.docs_dir)
         return resolve_unit_docs(self.docs_dir, unit), f"unit {unit}"
 
+    def sources(self, args: argparse.Namespace) -> dict[str, Path]:
+        """Source path for every resolved doc key (033): the regeneration
+        gate re-reads these from disk so a mid-run unit-plan edit is detected."""
+        unit = args.aidlc_unit or get_current_unit(self.docs_dir)
+        _, sources = resolve_unit_docs_with_sources(self.docs_dir, unit)
+        return sources
+
 
 class AidlcExtension:
     name = "ai-dlc"

{agentic_dev_loop-1.0.0a28 → agentic_dev_loop-1.0.0a30}/src/agentic_dev_loop/engine/graph.py

@@ -28,8 +28,9 @@ from .secrets import resolve_secrets, scan_env_files
 from .registry import (Registry, default_registry, load_extensions,
                        validate_action_mounts_egress, validate_action_network)
 from .stages import (Runtime, clear_attempt_artifacts,
-                     make_action_node, make_agent_node, make_bump_node,
-                     make_command_node, make_router, success_node)
+                     make_action_node, make_agent_node, make_brief_node,
+                     make_bump_node, make_command_node, make_router,
+                     success_node)
 
 CHECKPOINT_DB = "loop-checkpoints.sqlite"  # under state_dir, one DB per workspace
 
@@ -47,6 +48,7 @@ class LoopState(TypedDict):
     every other key is last-write-wins."""
     subject: str
     docs: dict[str, str]
+    doc_sources: dict[str, str]        # doc key -> source path (033 regeneration gate)
     artifacts: Annotated[dict[str, str], _merge_artifacts]  # step name -> artifact text
     attempt: int
     max_attempts: int
@@ -61,6 +63,7 @@ class LoopState(TypedDict):
     step_verdicts: dict[str, str | None]  # per-step pass/fail/None(unclear)
     retry_target: str | None           # where the bump node loops back to
     thread_id: str
+    brief_hashes: Annotated[dict[str, str], _merge_artifacts]  # step name -> input hash (033)
 
 
 def build_graph(runtime: Runtime, checkpointer=None):
@@ -83,7 +86,10 @@ def build_graph(runtime: Runtime, checkpointer=None):
     graph = StateGraph(LoopState)
     for step in runtime.cfg.steps:
         if step.kind == "agent":
-            node = make_agent_node(runtime, step)
+            if step.brief_inputs is not None:
+                node = make_brief_node(runtime, step)
+            else:
+                node = make_agent_node(runtime, step)
         elif step.kind == "command":
             node = make_command_node(runtime, step)
         else:
@@ -178,14 +184,15 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
     if resume:
         initial = None  # state (docs/subject/artifacts) comes from the checkpoint
     else:
-        _loader, docs, subject = resolve_docs(cfg, base, registry, args)
+        _loader, docs, subject, doc_sources = resolve_docs(cfg, base, registry, args)
         # A fresh run owns state_dir: drop cross-run leftovers (a previous
         # failure's last-error.md, stale artifacts) so nothing mistakes
         # them for this run's output. --resume keeps them.
-        clear_attempt_artifacts(runtime)
+        clear_attempt_artifacts(runtime, exempt_run_scoped=False)
         initial: LoopState = {
             "subject": subject,
             "docs": docs,
+            "doc_sources": doc_sources,
             "artifacts": {},
             "attempt": 1,
             "max_attempts": max_attempts,
@@ -204,6 +211,7 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
             "step_verdicts": {},
             "retry_target": None,
             "thread_id": thread_id,
+            "brief_hashes": {},
         }
     bus = viz_bus
     with SqliteSaver.from_conn_string(db) as saver:

{agentic_dev_loop-1.0.0a28 → agentic_dev_loop-1.0.0a30}/src/agentic_dev_loop/engine/isolation.py

@@ -144,6 +144,7 @@ class SandboxExecutionResult:
     duration_seconds: float
     backend: str  # "docker"
     timed_out: bool = False
+    wrote_workspace: bool = False  # declared-rw paths changed (032)
 
     @property
     def succeeded(self) -> bool:
@@ -1068,8 +1069,15 @@ class DockerBackend(Sandbox):
                 "failing closed (BR-11.3): no networked execution runs "
                 "without egress enforcement")
         result = self._exec(request, prof.name)
+        report: SyncBackReport | None = None
         if mount_set.rw_paths() and self._export_root is not None:
-            self._sync_back(mount_set)
+            report = self._sync_back(mount_set)
+        if report is not None and (report.synced_paths or report.merged_paths):
+            result = SandboxExecutionResult(
+                exit_code=result.exit_code, stdout=result.stdout,
+                stderr=result.stderr, duration_seconds=result.duration_seconds,
+                backend=result.backend, timed_out=result.timed_out,
+                wrote_workspace=True)
         return result
 
     def _exec(self, request: SandboxExecutionRequest,
@@ -1161,7 +1169,7 @@ class DockerBackend(Sandbox):
         export_path.parent.mkdir(parents=True, exist_ok=True)
         shutil.copy2(host_path, export_path, follow_symlinks=False)
 
-    def _sync_back(self, mount_set: MountSet) -> None:
+    def _sync_back(self, mount_set: MountSet) -> SyncBackReport | None:
         """Sync declared-rw export changes back to the real repo (BR-4/F1),
         git-aware, host-side, with the sandbox step already complete.
 
@@ -1227,6 +1235,7 @@ class DockerBackend(Sandbox):
             "synced_paths": list(report.synced_paths),
             "merged_paths": list(report.merged_paths),
         })
+        return report
 
     def close(self) -> None:
         """Best-effort stop + rm; idempotent (BR-8.3). With ``--rm`` the

{agentic_dev_loop-1.0.0a28 → agentic_dev_loop-1.0.0a30}/src/agentic_dev_loop/engine/loaders.py

@@ -71,6 +71,12 @@ class PlanDocumentLoader:
         docs = resolve_plan_docs(args.plan)
         return docs, f"plan {args.plan.name}"
 
+    def sources(self, args: argparse.Namespace) -> dict[str, Path]:
+        """Source path for every resolved doc key (033): the regeneration
+        gate re-reads these from disk so a mid-run plan edit is detected."""
+        path = Path(args.plan)
+        return {path.name: path}
+
 
 def select_loader(registry: Registry, args: argparse.Namespace) -> DocumentLoader | None:
     """The document-loader coexistence model - load many, invoke one:
@@ -103,11 +109,15 @@ def select_loader(registry: Registry, args: argparse.Namespace) -> DocumentLoade
 
 
 def resolve_docs(cfg: PipelineConfig, base: Path, registry: Registry,
-                 args) -> tuple[DocumentLoader | None, dict[str, str], str]:
+                 args) -> tuple[DocumentLoader | None, dict[str, str], str,
+                                dict[str, str]]:
     """Select and invoke the document loader, then append the pipeline's
     additional_files (resolved relative to the pipeline file's dir;
-    listed-but-missing fails fast). Returns (loader, docs, subject)."""
+    listed-but-missing fails fast). Returns (loader, docs, subject,
+    doc_sources) - the source path for every loader/additional_files doc key
+    so the brief regeneration gate can re-read them from disk (033 D4)."""
     loader = select_loader(registry, args)
+    sources: dict[str, str] = {}
     if loader is not None:
         docs, subject = loader.resolve(args)
         if not docs:
@@ -116,6 +126,10 @@ def resolve_docs(cfg: PipelineConfig, base: Path, registry: Registry,
             raise RuntimeError(
                 f"Document loader {loader.name!r} returned no docs - "
                 "refusing to build context from nothing")
+        loader_sources = getattr(loader, "sources", None)
+        if callable(loader_sources):
+            for name, path in loader_sources(args).items():
+                sources[name] = str(Path(path).resolve())
     else:
         docs, subject = {}, cfg.name
     for rel in cfg.additional_files:
@@ -123,4 +137,5 @@ def resolve_docs(cfg: PipelineConfig, base: Path, registry: Registry,
         if not path.is_file():
             raise FileNotFoundError(f"additional_files entry not found: {path}")
         docs[path.name] = path.read_text(encoding="utf-8")
-    return loader, docs, subject
+        sources[path.name] = str(path.resolve())
+    return loader, docs, subject, sources