agentic-dev-loop 1.0.0a15__tar.gz → 1.0.0a17__tar.gz

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a15
+Version: 1.0.0a17
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -213,7 +213,7 @@ steps:
 | `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 (command steps, network ON, stamp-cached); `network: true` grants egress to a command or agent step (default off) - see [Per-stage networking](#per-stage-networking). |
 | `secrets:` (top-level) / step `secrets:` | Declares secret **refs only - never values**; each step opts in to the refs it needs. Resolved host-side and injected into that step's exec env only. See [Secrets](#secrets--refs-only-never-values). |
-| `isolation:` (optional) | Configures the sandbox - image override, resource caps, `allow_git_mutations`. It can never disable it. |
+| `isolation:` (optional) | Configures the sandbox - image override, resource caps, `allow_git_mutations`, `seccomp_profile`. It can never disable it. See [browser sandbox](docs/browser-sandbox.md). |
 | `state_dir` | Defaults to `~/.agentic-dev-loop/runs/<pipeline-hash>/` - artifacts and checkpoints live outside the sandbox mount. |
 | `extensions_dir` | Where consumer `extensions:` modules resolve - defaults to `~/.agentic-dev-loop/extensions`, **outside** the workspace. Workspace-resident extension/tool modules are refused at load. |
 | `deps_policy` | `locked` (default) or `open`. `locked` = the human-owned lockfile is the source of truth and the agent may not add dependencies; `open` = the bootstrap protocol (the agent may add exact-pinned manifest entries). See [Dependency policy](#dependency-policy-locked-by-default). |
@@ -231,7 +231,7 @@ secrets:                              # refs only - never values
     key: KINDIE_CLIENT_SECRET         # provider-specific locator
   r2-keys:
     from: env
-    key: YOSK_R2_KEYS
+    key: R2_KEYS
 
 steps:
   - name: qa

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/README.md

@@ -171,7 +171,7 @@ steps:
 | `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 (command steps, network ON, stamp-cached); `network: true` grants egress to a command or agent step (default off) - see [Per-stage networking](#per-stage-networking). |
 | `secrets:` (top-level) / step `secrets:` | Declares secret **refs only - never values**; each step opts in to the refs it needs. Resolved host-side and injected into that step's exec env only. See [Secrets](#secrets--refs-only-never-values). |
-| `isolation:` (optional) | Configures the sandbox - image override, resource caps, `allow_git_mutations`. It can never disable it. |
+| `isolation:` (optional) | Configures the sandbox - image override, resource caps, `allow_git_mutations`, `seccomp_profile`. It can never disable it. See [browser sandbox](docs/browser-sandbox.md). |
 | `state_dir` | Defaults to `~/.agentic-dev-loop/runs/<pipeline-hash>/` - artifacts and checkpoints live outside the sandbox mount. |
 | `extensions_dir` | Where consumer `extensions:` modules resolve - defaults to `~/.agentic-dev-loop/extensions`, **outside** the workspace. Workspace-resident extension/tool modules are refused at load. |
 | `deps_policy` | `locked` (default) or `open`. `locked` = the human-owned lockfile is the source of truth and the agent may not add dependencies; `open` = the bootstrap protocol (the agent may add exact-pinned manifest entries). See [Dependency policy](#dependency-policy-locked-by-default). |
@@ -189,7 +189,7 @@ secrets:                              # refs only - never values
     key: KINDIE_CLIENT_SECRET         # provider-specific locator
   r2-keys:
     from: env
-    key: YOSK_R2_KEYS
+    key: R2_KEYS
 
 steps:
   - name: qa

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/pyproject.toml

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

@@ -87,11 +87,15 @@ class IsolationConfig(BaseModel):
     # the workspace - validated at startup, not load (the workspace is unknown
     # here).
     sandbox_venv_dir: str | None = None
-    # 023: optional host path to a Docker seccomp profile JSON. When set, the
-    # exec container runs with ``--security-opt seccomp=<path>`` in place of
-    # Docker's default profile. Used to allow Chromium's namespace sandbox
-    # (userns syscalls) under --cap-drop ALL. The path is validated by Docker
-    # at container-create time, not at load.
+    # 023/025: optional host path to a Docker seccomp profile JSON, or a
+    # ``bundled:<name>`` sentinel resolved at load to a packaged profile
+    # (e.g. ``bundled:chromium-userns``). When set, the exec container runs
+    # with ``--security-opt seccomp=<path>`` in place of Docker's default
+    # profile, plus ``--cap-add SYS_CHROOT`` (the profile gates chroot(2) on
+    # exactly that capability). Used to allow Chromium's namespace sandbox
+    # (userns syscalls) under --cap-drop ALL. An unknown sentinel name fails
+    # at load naming the known bundled profiles; a raw path is validated by
+    # Docker at container-create time, not at load.
     seccomp_profile: str | None = None
 
     @field_validator("memory")

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/src/agentic_dev_loop/engine/actions.py

@@ -1,6 +1,6 @@
 """Built-in pipeline actions. Node-shaped: (state, params) -> state update.
 
-`commit` policy (ported unchanged from yosk): agents never commit mid-run;
+`commit` policy (ported unchanged from the consumer): agents never commit mid-run;
 the pipeline commits exactly once, and only when the worktree was clean at
 run start - a dirty-at-start run is committed by the human, so the
 auto-commit can never swallow pre-existing unrelated changes (run 004: the

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/src/agentic_dev_loop/engine/dryrun.py

@@ -16,7 +16,7 @@ from agentic_dev_loop.core.config import PipelineConfig, StepConfig, load_config
 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)
+                        resolve_image_ref, resolved_seccomp_profile)
 from .registry import (Registry, default_registry, load_extensions,
                        validate_action_network)
 from .secrets import scan_env_files
@@ -134,6 +134,7 @@ 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>
 
     loader, docs, subject = resolve_docs(cfg, base, registry, args)
     image, memory, cpus = _resolved_image(cfg)

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/src/agentic_dev_loop/engine/graph.py

@@ -27,19 +27,27 @@ from .loaders import resolve_docs
 from .secrets import resolve_secrets, scan_env_files
 from .registry import (Registry, default_registry, load_extensions,
                        validate_action_network)
-from .stages import (Runtime, build_context, clear_attempt_artifacts,
+from .stages import (Runtime, clear_attempt_artifacts,
                      make_action_node, make_agent_node, make_bump_node,
                      make_command_node, make_router, success_node)
 
 CHECKPOINT_DB = "loop-checkpoints.sqlite"  # under state_dir, one DB per workspace
 
 
+def _merge_artifacts(a: dict[str, str], b: dict[str, str]) -> dict[str, str]:
+    """Accumulate per-step artifact text across nodes. LangGraph gives
+    un-annotated fields last-write-wins, so without this reducer one node's
+    entry would silently replace the accumulated dict."""
+    return {**a, **b}
+
+
 class LoopState(TypedDict):
     """State threaded through the graph. `notes` accumulates across attempts
-    (append reducer); every other key is last-write-wins."""
+    (append reducer), `artifacts` accumulates across stages (merge reducer);
+    every other key is last-write-wins."""
     subject: str
     docs: dict[str, str]
-    context: str                       # built at attempt start, shared by all stages
+    artifacts: Annotated[dict[str, str], _merge_artifacts]  # step name -> artifact text
     attempt: int
     max_attempts: int
     notes: Annotated[list[str], operator.add]
@@ -95,7 +103,7 @@ def run_pipeline(cfg_path, args, *, viz_bus=None,
                  registry: Registry | None = None) -> tuple[bool, int]:
     """Load a pipeline YAML, resolve docs via the selected document loader,
     and run the graph to completion. Returns (success, attempts) - the
-    public API, yosk's `construct`/`resume_loop` equivalent.
+    public API, the consumer's `construct`/`resume_loop` equivalent.
 
     `args` carries the parsed CLI namespace: loader flags, --resume,
     --max-attempts (which overrides the YAML value when set), and --no-viz.
@@ -163,7 +171,7 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
     config = {"configurable": {"thread_id": thread_id}}
     db = str(state_dir / CHECKPOINT_DB)
     if resume:
-        initial = None  # state (docs/subject/context) comes from the checkpoint
+        initial = None  # state (docs/subject/artifacts) comes from the checkpoint
     else:
         _loader, docs, subject = resolve_docs(cfg, base, registry, args)
         # A fresh run owns state_dir: drop cross-run leftovers (a previous
@@ -173,7 +181,7 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
         initial: LoopState = {
             "subject": subject,
             "docs": docs,
-            "context": build_context(runtime, docs, subject, []),
+            "artifacts": {},
             "attempt": 1,
             "max_attempts": max_attempts,
             "notes": [],
@@ -221,7 +229,8 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
                     f"Failure details: {state_dir}/last-error.md",
                     flush=True)
                 initial = {**values, "failed": False,
-                           "resume_target": target, "failed_step": None}
+                           "resume_target": target, "failed_step": None,
+                           "artifacts": values.get("artifacts", {})}
 
         if bus is None and not getattr(args, "no_viz", True):
             start_state = initial if initial is not None \

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/src/agentic_dev_loop/engine/hostboundary.py

@@ -29,7 +29,7 @@ if TYPE_CHECKING:
     from agentic_dev_loop.core.config import PipelineConfig
 
 # Tooling directories are workspace-root-relative fixed names (the same layout
-# the dogfood pipeline and yosk use); the other tooling paths are config- or
+# the dogfood pipeline and the consumer repo use); the other tooling paths are config- or
 # pipeline-file-relative.
 TOOLING_DIR_NAMES = ("aidlc-docs", "tools")
 

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/src/agentic_dev_loop/engine/isolation.py

@@ -37,6 +37,7 @@ from typing import Protocol
 
 from agentic_dev_loop.core.config import IsolationConfig, PipelineConfig
 from .proc import needs_shell, split_command
+from .seccomp import resolve_seccomp_profile
 
 # ---------------------------------------------------------------------------
 # Constants (KD-2 / ID-4)
@@ -480,7 +481,9 @@ def docker_create_payload(*, run_id: str, image: str, profile: EffectiveProfile,
     CAP_SYS_CHROOT; the profile gates chroot(2) on exactly that capability,
     so the payload adds it back (the bounding set is otherwise empty under
     --cap-drop ALL). Without the cap the zygote dies even with the profile
-    (023 host-side gate 2)."""
+    (023 host-side gate 2). The ``--cap-add SYS_CHROOT`` applies to any
+    seccomp profile by design: the bundled profile requires it, and custom
+    profiles are expected to follow the same cap-gated pattern."""
     payload = [
         "docker", "run", "--detach", "--rm", "--name",
         exec_container_name(run_id, network),
@@ -956,6 +959,14 @@ def isolation_state_dir(cfg: PipelineConfig) -> Path:
     return Path(iso.state_dir).expanduser()
 
 
+def resolved_seccomp_profile(cfg: PipelineConfig) -> str | None:
+    """The pipeline's seccomp profile with any ``bundled:<name>`` sentinel
+    expanded to a real host path (025). A raw path passes through unchanged
+    and is still validated by Docker at container-create time."""
+    return resolve_seccomp_profile(
+        cfg.isolation.seccomp_profile if cfg.isolation else None)
+
+
 def resolve_image_ref(image: str, environ: Mapping[str, str] | None = None) -> str:
     """AGENTIC_DEV_LOOP_DEV_IMAGE override (tag OR digest) → else the profile
     image (digest-pinned) → if empty, fail fast AE-SBX-005."""
@@ -976,6 +987,7 @@ def startup_sandbox(cfg: PipelineConfig, *, workspace: Path,
                     refresh: bool | None = None) -> Sandbox:
     """Eager startup sequence (Q2): probe → image → backend → ensure_image →
     create+start → pre-provision every declared setup (stamp-cached)."""
+    seccomp_profile = resolved_seccomp_profile(cfg)
     probe_docker(runner)
     profile = resolve_effective_profile(cfg.isolation)
     image = resolve_image_ref(profile.image)
@@ -983,7 +995,6 @@ def startup_sandbox(cfg: PipelineConfig, *, workspace: Path,
     needs_network = any(step.network for step in cfg.steps)
     sandbox_venv_dir = resolve_sandbox_venv_dir(
         cfg.isolation.sandbox_venv_dir if cfg.isolation else None, workspace)
-    seccomp_profile = cfg.isolation.seccomp_profile if cfg.isolation else None
     backend = DockerBackend(
         image=image, workspace=str(workspace), iso_state_dir=str(iso_state_dir),
         profile=profile, runner=runner, network=needs_network,

agentic_dev_loop-1.0.0a17/src/agentic_dev_loop/engine/seccomp/__init__.py

@@ -0,0 +1,72 @@
+"""Bundled Docker seccomp profiles (023).
+
+Docker's default seccomp profile blocks the user-namespace syscalls Chromium's
+namespace sandbox needs, which makes ``chromium.launch(chromiumSandbox=True)``
+die at the zygote under ``--cap-drop ALL``. These profiles are Docker's default
+profile with an allowlist for those userns syscalls; pass one as
+``isolation.seccomp_profile`` to swap it in. The ``bundled:<name>`` sentinel
+(025) resolves a profile by name so consumers declare intent instead of
+rediscovering the packaged path.
+"""
+
+from __future__ import annotations
+
+from importlib.resources import as_file, files
+
+CHROMIUM_USERNS_NAME = "chromium-userns"
+CHROMIUM_USERNS_PROFILE = "chromium-userns.json"
+
+# ``bundled:<name>`` sentinel suffix -> packaged JSON filename. This is the
+# single registry new bundled profiles slot into (025).
+BUNDLED_PROFILES = {
+    CHROMIUM_USERNS_NAME: CHROMIUM_USERNS_PROFILE,
+}
+
+
+def _profile_path(filename: str) -> str:
+    """Host filesystem path to a packaged seccomp profile JSON."""
+    traversable = files("agentic_dev_loop.engine.seccomp").joinpath(filename)
+    with as_file(traversable) as path:
+        return str(path)
+
+
+def bundled_profile_path(name: str) -> str:
+    """Host filesystem path to the named bundled seccomp profile.
+
+    Raises ``ValueError`` listing every known ``bundled:<name>`` when ``name``
+    is unknown, so a bad sentinel fails loud at load instead of at
+    container-create time.
+    """
+    filename = BUNDLED_PROFILES.get(name)
+    if filename is None:
+        known = ", ".join(f"bundled:{n}" for n in sorted(BUNDLED_PROFILES))
+        raise ValueError(
+            f"unknown bundled seccomp profile {name!r} (known: {known})")
+    return _profile_path(filename)
+
+
+def chromium_userns_profile_path() -> str:
+    """Host filesystem path to the bundled Chromium userns seccomp profile.
+
+    Docker's ``--security-opt seccomp=<path>`` takes a host path, so the JSON
+    must resolve to a real file. Wheels unpack to disk, so ``as_file`` returns
+    the installed path without copying.
+    """
+    return bundled_profile_path(CHROMIUM_USERNS_NAME)
+
+
+def resolve_seccomp_profile(value: str | None) -> str | None:
+    """Expand a ``bundled:<name>`` sentinel to its real profile path (025).
+
+    A raw host path passes through unchanged (Docker still validates it at
+    container-create time, unchanged from 023). An unknown or empty bundled
+    name fails loud with every known ``bundled:<name>``.
+    """
+    if value is None or not value.startswith("bundled:"):
+        return value
+    name = value[len("bundled:"):]
+    if not name:
+        known = ", ".join(f"bundled:{n}" for n in sorted(BUNDLED_PROFILES))
+        raise ValueError(
+            f"seccomp_profile 'bundled:' is missing a name (known: {known})")
+    return bundled_profile_path(name)

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/src/agentic_dev_loop/engine/stages.py

@@ -1,6 +1,6 @@
 """Stage nodes, routers, and the run_agent port.
 
-The yosk loop's hardcoded stages become per-step closures built from the
+The consumer loop's hardcoded stages become per-step closures built from the
 pipeline config; the fixed policies stay here, not in config:
 
 - per-attempt hygiene: every declared artifact/produces file + last-error.md
@@ -49,6 +49,7 @@ if TYPE_CHECKING:
 DEFAULT_MAX_ITERATIONS = 500
 DEFAULT_COMMAND_TIMEOUT = 600.0  # seconds - a pytest-class suite budget
 LAST_ERROR = "last-error.md"
+ARTIFACT_CONTEXT_CAP = 24_000  # chars per artifact injected into a step's context
 
 
 @dataclass
@@ -68,7 +69,7 @@ class Runtime:
 def prompt_dir(runtime: Runtime) -> str:
     """state_dir as agents must address it. Agents resolve prompt paths
     against their workspace, so a bare `state_dir.name` only reaches the real
-    state_dir when the pipeline file sits at the workspace root - yosk runs
+    state_dir when the pipeline file sits at the workspace root - the consumer runs
     agentic-dev-loop/pipeline.yaml from the repo root, where `.pr` and
     `agentic-dev-loop/.pr` diverge. Workspace-relative when under the workspace,
     the absolute path when outside it."""
@@ -196,15 +197,41 @@ def _run_command(command: str, workspace: Path, timeout: float,
         return None, out.decode("utf-8", "replace"), True
 
 
+def _artifact_file(runtime: Runtime, step_name: str) -> str | None:
+    """The declared artifact/produces filename a step writes, keyed by step
+    name - the artifacts dict only carries step name -> captured text."""
+    for step in runtime.cfg.steps:
+        if step.name == step_name:
+            if step.artifact is not None:
+                return step.artifact
+            if step.produces:
+                return step.produces[0]
+            return None
+    return None
+
+
 def build_context(runtime: Runtime, docs: dict[str, str], subject: str,
-                  notes: list[str] | None = None) -> str:
+                  notes: list[str] | None = None,
+                  artifacts: dict[str, str] | None = None) -> str:
     """Assemble the attempt's shared message: subject, doc bundle, the
     canonical dependency-policy paragraph (021), the expected-output-paths
     section generated from step defs (a prompt merely naming files lets agents
-    skip them), and previous-attempt notes."""
+    skip them), accumulated stage artifacts (027), and previous-attempt
+    notes."""
     parts = [f"You are working on {subject}.\n"]
     for name, content in docs.items():
         parts.append(f"## {name}\n\n{content}")
+    if artifacts:
+        parts.append("## Stage artifacts")
+        for step_name, content in artifacts.items():
+            capped = content[:ARTIFACT_CONTEXT_CAP]
+            if len(content) > ARTIFACT_CONTEXT_CAP:
+                filename = _artifact_file(runtime, step_name)
+                path = (f"{prompt_dir(runtime)}/{filename}" if filename
+                        else prompt_dir(runtime))
+                capped += (f"\n\n[... content truncated - full text at "
+                           f"`{path}`]")
+            parts.append(f"### {step_name}\n\n{capped}")
     parts.append("## Dependency policy\n\n" + policy_injection(runtime.cfg))
     lines = []
     for step in runtime.cfg.steps:
@@ -240,7 +267,7 @@ def clear_attempt_artifacts(runtime: Runtime) -> None:
 
 def _unclear_target(runtime: Runtime, step: StepConfig) -> str:
     """Where the unclear-verdict retry loops to: on_fail's goto when that is
-    a step, else the entry step (yosk always looped back to dev)."""
+    a step, else the entry step (the consumer always looped back to dev)."""
     target = route_target(step.on_fail)
     if target is not None and target not in TERMINALS:
         return target
@@ -295,8 +322,11 @@ def make_agent_node(runtime: Runtime, step: StepConfig):
         attempt = state["attempt"]
         subject = state["subject"]
         max_iterations = step.max_iterations or DEFAULT_MAX_ITERATIONS
+        message = build_context(runtime, state["docs"], state["subject"],
+                                state["notes"],
+                                artifacts=state.get("artifacts", {}))
         print(f"[{subject}] Running {step.agent} agent...", flush=True)
-        result = run_agent(step.agent, state["context"], runtime,
+        result = run_agent(step.agent, message, runtime,
                            max_iterations=max_iterations, step=step)
         if not result.ok:
             print(f"[{subject}] {step.name} agent failed on attempt {attempt}.", flush=True)
@@ -330,7 +360,10 @@ def make_agent_node(runtime: Runtime, step: StepConfig):
         if verdicts_map is None:
             merged = {**state["step_verdicts"], step.name: "pass"} if captures else \
                 state["step_verdicts"]
-            return {"step_verdicts": merged, "failed": False}
+            update = {"step_verdicts": merged, "failed": False}
+            if captures and result.response is not None:
+                update["artifacts"] = {step.name: result.response}
+            return update
 
         parsed = Verdict.from_text(result.response or "", verdicts_map)
         merged = {**state["step_verdicts"], step.name: None}
@@ -340,16 +373,24 @@ def make_agent_node(runtime: Runtime, step: StepConfig):
             if verdict == "pass":
                 print(f"[{subject}] {step.name} VERDICT: PASS on attempt {attempt}.",
                       flush=True)
-                return {"step_verdicts": merged, "failed": False}
+                update = {"step_verdicts": merged, "failed": False}
+                if captures and result.response is not None:
+                    update["artifacts"] = {step.name: result.response}
+                return update
             if verdict == "unverifiable":
                 print(f"[{subject}] {step.name} qa verdict: UNVERIFIABLE "
                       f"(moves on).", flush=True)
-                return {"step_verdicts": merged, "failed": False}
+                update = {"step_verdicts": merged, "failed": False}
+                if captures and result.response is not None:
+                    update["artifacts"] = {step.name: result.response}
+                return update
             print(f"[{subject}] {step.name} verdict: fail on attempt {attempt}.",
                   flush=True)
             update = {"step_verdicts": merged,
                       "notes": [f"## {step.name} output (attempt {attempt})\n\n"
                                 f"{result.response}"]}
+            if captures and result.response is not None:
+                update["artifacts"] = {step.name: result.response}
             if isinstance(step.on_fail, Route) and step.on_fail.retry:
                 update["retry_target"] = step.on_fail.goto
             return update
@@ -548,16 +589,14 @@ def make_router(runtime: Runtime, step: StepConfig):
 
 def make_bump_node(runtime: Runtime):
     """Close the retry cycle: consume one attempt, clear per-attempt
-    artifacts, and rebuild the context with the accumulated notes - the
-    attempt-start duties yosk's dev node owned, generalized to any target."""
+    artifacts, and reset verdicts/failed for the next attempt. The retried
+    agent's message is rebuilt per run by make_agent_node from the
+    accumulated notes and artifacts (027)."""
 
     def node(state: dict) -> dict:
         clear_attempt_artifacts(runtime)
-        context = build_context(runtime, state["docs"], state["subject"],
-                                state["notes"])
         return {"attempt": state["attempt"] + 1,
                 "step_verdicts": {},
-                "context": context,
                 "failed": False}
 
     return node

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/src/agentic_dev_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a15
+Version: 1.0.0a17
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -213,7 +213,7 @@ steps:
 | `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 (command steps, network ON, stamp-cached); `network: true` grants egress to a command or agent step (default off) - see [Per-stage networking](#per-stage-networking). |
 | `secrets:` (top-level) / step `secrets:` | Declares secret **refs only - never values**; each step opts in to the refs it needs. Resolved host-side and injected into that step's exec env only. See [Secrets](#secrets--refs-only-never-values). |
-| `isolation:` (optional) | Configures the sandbox - image override, resource caps, `allow_git_mutations`. It can never disable it. |
+| `isolation:` (optional) | Configures the sandbox - image override, resource caps, `allow_git_mutations`, `seccomp_profile`. It can never disable it. See [browser sandbox](docs/browser-sandbox.md). |
 | `state_dir` | Defaults to `~/.agentic-dev-loop/runs/<pipeline-hash>/` - artifacts and checkpoints live outside the sandbox mount. |
 | `extensions_dir` | Where consumer `extensions:` modules resolve - defaults to `~/.agentic-dev-loop/extensions`, **outside** the workspace. Workspace-resident extension/tool modules are refused at load. |
 | `deps_policy` | `locked` (default) or `open`. `locked` = the human-owned lockfile is the source of truth and the agent may not add dependencies; `open` = the bootstrap protocol (the agent may add exact-pinned manifest entries). See [Dependency policy](#dependency-policy-locked-by-default). |
@@ -231,7 +231,7 @@ secrets:                              # refs only - never values
     key: KINDIE_CLIENT_SECRET         # provider-specific locator
   r2-keys:
     from: env
-    key: YOSK_R2_KEYS
+    key: R2_KEYS
 
 steps:
   - name: qa

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/tests/test_actions.py

@@ -1,4 +1,4 @@
-"""Action tests - ported from yosk's TestKillListenersOnPort /
+"""Action tests - ported from the consumer's TestKillListenersOnPort /
 TestGitWorktreeClean / TestCommitNode, retargeted at the node-shaped
 `(state, params) -> dict` API. Real processes and real git repos throughout:
 git and sockets are local utilities, not network boundaries."""

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/tests/test_agents.py

@@ -1,4 +1,4 @@
-"""load_agent tests - ported from yosk's TestLoadAgent, retargeted at the
+"""load_agent tests - ported from the consumer's TestLoadAgent, retargeted at the
 library signature which also builds the Agent via the SDK factory. Real
 agent files on disk (fail-fast file policy); real LLM/Agent SDK objects
 (constructed locally, no network)."""

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/tests/test_config.py

@@ -6,14 +6,14 @@ from pydantic import ValidationError
 
 from agentic_dev_loop.core.config import Route, default_state_dir, load_config
 
-# The plan's yosk-equivalent reference pipeline (009, YAML schema section),
+# The plan's reference pipeline (consumer-equivalent) (009, YAML schema section),
 # verbatim except for two substitutions: 012 replaced the agent step named
 # `test` (artifact ci-fix.md, PASS/FAIL) with the mechanical command step
 # named `test` - same position, same on_fail wiring; and 009 dropped the
 # port_sweep step (its sweep moved into engine startup, no longer a pipeline
 # step). This is the canonical pin: the documented schema must load.
 FULL_YAML = """\
-name: yosk-construction
+name: reference-construction
 
 extensions:
   - agentic_dev_loop.engine.extensions.aidlc:AidlcExtension
@@ -86,7 +86,7 @@ def test_full_schema_example_round_trips(tmp_path):
     p.write_text(FULL_YAML)
     cfg = load_config(p)
 
-    assert cfg.name == "yosk-construction"
+    assert cfg.name == "reference-construction"
     assert cfg.extensions == ["agentic_dev_loop.engine.extensions.aidlc:AidlcExtension"]
     assert cfg.additional_files == ["coding-standards-ddd.yaml"]
     assert cfg.state_dir == ".pr"

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/tests/test_graph.py

@@ -1,6 +1,6 @@
 """Graph builder + run_pipeline behavioral tests.
 
-The yosk-equivalent YAML below must reproduce the hardcoded loop's behavior:
+The consumer-equivalent YAML below must reproduce the hardcoded loop's behavior:
 dev → check → review → qa → commit, retries to dev, failure on
 exhaustion/exception. run_agent is stubbed (the SDK network boundary);
 everything else - files, git, checkpoints - is real."""
@@ -21,8 +21,8 @@ from agentic_dev_loop.engine.registry import Registry, default_registry, load_ex
 from agentic_dev_loop.engine.stages import Runtime
 from agentic_dev_loop.viz import VizBus
 
-YOSK_YAML = """\
-name: yosk-construction
+REFERENCE_YAML = """\
+name: reference-construction
 extensions:
   - agentic_dev_loop.engine.extensions.aidlc:AidlcExtension
 additional_files:
@@ -101,10 +101,10 @@ def git(repo: Path, *args: str) -> str:
 
 @pytest.fixture
 def repo(tmp_path, monkeypatch, fake_sandbox):
-    """A real git repo with the yosk-equivalent pipeline committed clean."""
+    """A real git repo with the consumer-equivalent pipeline committed clean."""
     repo = tmp_path / "repo"
     repo.mkdir()
-    (repo / "pipeline.yaml").write_text(YOSK_YAML)
+    (repo / "pipeline.yaml").write_text(REFERENCE_YAML)
     (repo / "coding-standards-ddd.yaml").write_text("STANDARDS")
     (repo / "plan.md").write_text("THE PLAN")
     git(repo, "init")
@@ -131,7 +131,7 @@ def script_all_pass(fake_agents):
 
 
 class TestTopology:
-    def test_yosk_pipeline_node_set(self, repo):
+    def test_reference_pipeline_node_set(self, repo):
         cfg = load_config(Path("pipeline.yaml"))
         registry = default_registry()
         load_extensions(cfg.extensions, registry)
@@ -143,7 +143,7 @@ class TestTopology:
                 "bump", "success"} <= nodes
 
     def test_unknown_action_fails_at_build(self, repo):
-        (repo / "bad.yaml").write_text(YOSK_YAML.replace(
+        (repo / "bad.yaml").write_text(REFERENCE_YAML.replace(
             "action: commit", "action: no_such_action"))
         cfg = load_config(Path("bad.yaml"))
         runtime = Runtime(cfg=cfg, registry=default_registry(),
@@ -178,6 +178,31 @@ class TestRunPipeline:
         second_dev = fake_agents.messages_for("dev")[1]
         assert "broken build" in second_dev  # fail note reached the next attempt
 
+    def test_downstream_agent_sees_prior_artifact(self, repo, fake_agents):
+        script_all_pass(fake_agents)
+        ok, attempts = run_pipeline("pipeline.yaml", args())
+        assert (ok, attempts) == (True, 1)
+        (dev_msg,) = fake_agents.messages_for("dev")
+        (check_msg,) = fake_agents.messages_for("check")
+        assert "## Stage artifacts" not in dev_msg  # runs before anything accumulates
+        assert "## Stage artifacts" in check_msg
+        assert "built it" in check_msg  # dev's captured response reached check
+
+    def test_retry_injects_review_artifact_notes_and_prior_dev(self, repo,
+                                                               fake_agents):
+        script_all_pass(fake_agents)
+        fake_agents.set("review", [
+            ("write", "review-findings.md", "VERDICT: NEEDS CHANGES\nfix the thing"),
+            ("write", "review-findings.md", "VERDICT: APPROVED"),
+        ])
+        ok, attempts = run_pipeline("pipeline.yaml", args())
+        assert (ok, attempts) == (True, 2)
+        second_dev = fake_agents.messages_for("dev")[1]
+        assert "## Stage artifacts" in second_dev
+        assert "built it" in second_dev          # dev's own attempt-1 artifact
+        assert "fix the thing" in second_dev      # review artifact + fail note
+        assert "## Previous attempt feedback" in second_dev
+
     def test_exhaustion_fails(self, repo, fake_agents):
         script_all_pass(fake_agents)
         fake_agents.set("check", [("write", "ci-fix.md", "VERDICT: FAIL")])
@@ -248,7 +273,7 @@ class TestRunPipeline:
         # is not a tooling modification - the loader's missing-file guard is
         # what catches it.
         (repo / "pipeline.yaml").write_text(
-            YOSK_YAML.replace("coding-standards-ddd.yaml",
+            REFERENCE_YAML.replace("coding-standards-ddd.yaml",
                               "no-such-shared-file.yaml"))
         git(repo, "add", "-A")
         git(repo, "commit", "-m", "reference missing additional file")
@@ -257,7 +282,7 @@ class TestRunPipeline:
         assert fake_agents.calls == []
 
     def test_empty_loader_docs_fail_fast(self, repo, fake_agents):
-        (repo / "empty.yaml").write_text(YOSK_YAML.replace(
+        (repo / "empty.yaml").write_text(REFERENCE_YAML.replace(
             "agentic_dev_loop.engine.extensions.aidlc:AidlcExtension",
             "sample_ext:EmptyLoaderExtension"))
         git(repo, "add", "-A")
@@ -267,7 +292,7 @@ class TestRunPipeline:
         assert fake_agents.calls == []
 
 
-LOCKED_YAML = YOSK_YAML.replace(
+LOCKED_YAML = REFERENCE_YAML.replace(
     "deps_policy: open\n",
     "deps_policy: locked\nlockfiles: [uv.lock]\n",
     1)

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/tests/test_isolation.py

@@ -1097,6 +1097,54 @@ class TestStartupSandbox:
         finally:
             sandbox.close()
 
+    def test_bundled_seccomp_sentinel_resolved_and_plumbed(self, tmp_path, monkeypatch):
+        """025: a ``bundled:chromium-userns`` sentinel is expanded to the real
+        packaged path before the exec payload is built, so the payload sees a
+        plain path and emits the profile plus the cap-gated SYS_CHROOT add."""
+        from agentic_dev_loop.engine.isolation import startup_sandbox
+        from agentic_dev_loop.engine.seccomp import chromium_userns_profile_path
+
+        ws = tmp_path / "ws"
+        ws.mkdir()
+        cfg = self._cfg(tmp_path, with_setup=False)
+        cfg.isolation.seccomp_profile = "bundled:chromium-userns"
+        monkeypatch.setattr("agentic_dev_loop.engine.isolation.shutil.which",
+                            lambda *a: "/usr/bin/docker")
+        monkeypatch.setenv("AGENTIC_DEV_LOOP_DEV_IMAGE", "img:tag")
+        runner = FakeRunner(
+            ok("1.54"),   # probe version
+            ok("linux"),  # probe ostype
+            ok(""),       # image inspect
+            ok(""),       # docker run -d --rm (exec container)
+        )
+        sandbox = startup_sandbox(cfg, workspace=ws, runner=runner)
+        try:
+            run_argv = [c for c in runner.calls if c[:2] == ["docker", "run"]][0]
+            resolved = chromium_userns_profile_path()
+            assert "--security-opt" in run_argv
+            assert run_argv[run_argv.index("--security-opt") + 1] == f"seccomp={resolved}"
+            assert "--cap-add" in run_argv
+            assert run_argv[run_argv.index("--cap-add") + 1] == "SYS_CHROOT"
+        finally:
+            sandbox.close()
+
+    def test_unknown_bundled_seccomp_name_fails_before_docker_probe(self, tmp_path, monkeypatch):
+        """025: an unknown bundled:<name> fails loud at startup, before any
+        Docker probe runs."""
+        from agentic_dev_loop.engine.isolation import startup_sandbox
+
+        ws = tmp_path / "ws"
+        ws.mkdir()
+        cfg = self._cfg(tmp_path, with_setup=False)
+        cfg.isolation.seccomp_profile = "bundled:unknown-name"
+        monkeypatch.setattr("agentic_dev_loop.engine.isolation.shutil.which",
+                            lambda *a: "/usr/bin/docker")
+        monkeypatch.setenv("AGENTIC_DEV_LOOP_DEV_IMAGE", "img:tag")
+        runner = FakeRunner()
+        with pytest.raises(ValueError, match="bundled:chromium-userns"):
+            startup_sandbox(cfg, workspace=ws, runner=runner)
+        assert runner.calls == []
+
     def test_in_workspace_sandbox_venv_dir_fails_loud(self, tmp_path, monkeypatch):
         from agentic_dev_loop.engine.isolation import startup_sandbox
 
@@ -1155,3 +1203,60 @@ class TestBundledSeccompProfile:
         path = Path(chromium_userns_profile_path())
         assert path.is_file()
         assert json.loads(path.read_text(encoding="utf-8"))["defaultAction"]             == "SCMP_ACT_ERRNO"
+
+
+class TestResolveSeccompProfile:
+    """025: the ``bundled:<name>`` sentinel resolves to a packaged profile
+    path; raw host paths pass through unchanged; unknown names fail loud with
+    every known bundled name."""
+
+    def test_bundled_sentinel_resolves_to_real_path(self):
+        from agentic_dev_loop.engine.seccomp import (chromium_userns_profile_path,
+                                                     resolve_seccomp_profile)
+
+        resolved = resolve_seccomp_profile("bundled:chromium-userns")
+        assert resolved == chromium_userns_profile_path()
+        assert Path(resolved).is_file()
+
+    def test_unknown_bundled_name_lists_known(self):
+        from agentic_dev_loop.engine.seccomp import resolve_seccomp_profile
+
+        with pytest.raises(ValueError, match="bundled:chromium-userns"):
+            resolve_seccomp_profile("bundled:unknown-name")
+
+    def test_empty_bundled_name_lists_known(self):
+        from agentic_dev_loop.engine.seccomp import resolve_seccomp_profile
+
+        with pytest.raises(ValueError, match="bundled:chromium-userns"):
+            resolve_seccomp_profile("bundled:")
+
+    def test_none_passes_through(self):
+        from agentic_dev_loop.engine.seccomp import resolve_seccomp_profile
+
+        assert resolve_seccomp_profile(None) is None
+
+    def test_raw_path_passes_through(self):
+        from agentic_dev_loop.engine.seccomp import resolve_seccomp_profile
+
+        assert resolve_seccomp_profile(
+            "/host/chromium-userns.json") == "/host/chromium-userns.json"
+
+    def test_bundled_profile_path_unknown_name(self):
+        from agentic_dev_loop.engine.seccomp import bundled_profile_path
+
+        with pytest.raises(ValueError, match="bundled:chromium-userns"):
+            bundled_profile_path("nope")
+
+    def test_sentinel_resolves_into_payload(self):
+        """025: the resolved sentinel path reaches ``docker_create_payload``
+        unchanged, producing the profile security-opt and the cap-add."""
+        from agentic_dev_loop.engine.seccomp import resolve_seccomp_profile
+
+        resolved = resolve_seccomp_profile("bundled:chromium-userns")
+        payload = docker_create_payload(
+            run_id="r1", image="img",
+            profile=EffectiveProfile(True, True, True, True, True,
+                                     "img", "4g", 2.0),
+            workspace="/ws", seccomp_profile=resolved)
+        assert payload[payload.index("--security-opt") + 1] == f"seccomp={resolved}"
+        assert payload[payload.index("--cap-add") + 1] == "SYS_CHROOT"

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/tests/test_qa_prompt.py

@@ -27,3 +27,11 @@ def test_unverifiable_verdict_rules_present():
 
 def test_inconclusive_budget_rule_retained():
     assert "INCONCLUSIVE" in _text()
+
+
+def test_probe_plan_rules_present():
+    text = _text()
+    assert "**Variant matrix.**" in text
+    assert "**Outcome probes.**" in text
+    assert "**Concurrency probes.**" in text
+    assert "**Error messages are assertions.**" in text

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/tests/test_secrets.py

@@ -38,7 +38,7 @@ def _cfg_with_secrets(tmp_path) -> PipelineConfig:
     data = _base()
     data["secrets"] = {
         "kinde-client-secret": {"from": "env", "key": "KINDIE_CLIENT_SECRET"},
-        "r2-keys": {"from": "env", "key": "YOSK_R2_KEYS"},
+        "r2-keys": {"from": "env", "key": "R2_KEYS"},
     }
     data["steps"] = [
         {"name": "qa", "agent": "qa", "secrets": ["kinde-client-secret"],
@@ -127,7 +127,7 @@ class TestProviderResolution:
     def test_resolve_secrets_returns_ref_keyed_values(self, tmp_path):
         cfg = _cfg_with_secrets(tmp_path)
         resolved = resolve_secrets(cfg, {"KINDIE_CLIENT_SECRET": "kinde-secret",
-                                         "YOSK_R2_KEYS": "r2-keys"})
+                                         "R2_KEYS": "r2-keys"})
         assert resolved == {"kinde-client-secret": "kinde-secret",
                             "r2-keys": "r2-keys"}
 
@@ -137,14 +137,14 @@ class TestProviderResolution:
             resolve_secrets(cfg, {"KINDIE_CLIENT_SECRET": "kinde-secret"})
         msg = str(e.value)
         assert "r2-keys" in msg
-        assert "YOSK_R2_KEYS" in msg
+        assert "R2_KEYS" in msg
         assert "env" in msg
         assert "['<none>']" in msg  # r2-keys is declared but unused by any step
 
     def test_resolve_secrets_missing_used_ref_names_step(self, tmp_path):
         cfg = _cfg_with_secrets(tmp_path)
         with pytest.raises(SecretResolutionError) as e:
-            resolve_secrets(cfg, {"YOSK_R2_KEYS": "r2-keys"})
+            resolve_secrets(cfg, {"R2_KEYS": "r2-keys"})
         assert "kinde-client-secret" in str(e.value)
         assert "['qa']" in str(e.value)
 

{agentic_dev_loop-1.0.0a15 → agentic_dev_loop-1.0.0a17}/tests/test_stages.py

@@ -1,6 +1,6 @@
 """Stage nodes, routers, context assembly, and the run_agent port.
 
-The yosk hardcoded stages (dev/test/review/qa + bump) become per-step node
+The consumer hardcoded stages (dev/test/review/qa + bump) become per-step node
 and router closures built from the pipeline config; the fixed policies
 (hygiene, verdict-first truncation, unclear-verdict retry, notes) stay here."""
 
@@ -17,8 +17,9 @@ from openhands.sdk.conversation.state import ConversationExecutionStatus
 from agentic_dev_loop.core.config import PipelineConfig
 from agentic_dev_loop.engine.registry import Registry, default_registry
 from agentic_dev_loop.engine.stages import (
-    Runtime, _run_command, build_context, make_action_node, make_agent_node,
-    make_bump_node, make_command_node, make_router, run_agent,
+    ARTIFACT_CONTEXT_CAP, Runtime, _run_command, build_context,
+    make_action_node, make_agent_node, make_bump_node, make_command_node,
+    make_router, run_agent,
 )
 
 
@@ -53,7 +54,7 @@ def runtime(tmp_path, fake_sandbox):
 
 def make_state(**over):
     state = {"subject": "plan plan.md", "docs": {"plan.md": "THE PLAN"},
-             "context": "CTX", "attempt": 1, "max_attempts": 3, "notes": [],
+             "artifacts": {}, "attempt": 1, "max_attempts": 3, "notes": [],
              "failed": False, "outcome": None, "commit_allowed": False,
              "step_verdicts": {}, "retry_target": None, "thread_id": "t1"}
     state.update(over)
@@ -78,7 +79,7 @@ class TestBuildContext:
         assert "## Previous attempt feedback\n\nnote one\n\nnote two" in ctx
 
     def test_output_paths_workspace_relative_for_subdirectory_pipeline(self, tmp_path):
-        """yosk layout: the pipeline YAML lives in a subdirectory while the
+        """consumer layout: the pipeline YAML lives in a subdirectory while the
         workspace is the repo root - the prompt path must reach the real
         state_dir; state_dir.name alone sends agents to the wrong directory
         (U18 burned 3 attempts on an unfindable ci-fix.md)."""
@@ -114,6 +115,27 @@ class TestBuildContext:
         assert "dev agent writes:" in ctx
         assert "test agent writes:" not in ctx
 
+    def test_artifacts_render_one_subsection_per_artifact_in_order(self, runtime):
+        ctx = build_context(runtime, {}, "s", [],
+                            artifacts={"dev": "summary text",
+                                       "review": "findings text"})
+        assert "## Stage artifacts" in ctx
+        assert "### dev\n\nsummary text" in ctx
+        assert "### review\n\nfindings text" in ctx
+        assert ctx.index("### dev") < ctx.index("### review")  # dict order
+
+    def test_artifact_content_capped_with_run_state_path_marker(self, runtime):
+        big = "x" * (ARTIFACT_CONTEXT_CAP + 100)
+        ctx = build_context(runtime, {}, "s", [], artifacts={"dev": big})
+        assert "x" * ARTIFACT_CONTEXT_CAP in ctx
+        assert "x" * (ARTIFACT_CONTEXT_CAP + 100) not in ctx
+        assert ("[... content truncated - full text at "
+                "`.pr/implementation-summary.md`]") in ctx
+
+    def test_no_artifacts_renders_no_section(self, runtime):
+        ctx = build_context(runtime, {}, "s", [])
+        assert "## Stage artifacts" not in ctx
+
 
 class TestDepsPolicyContext:
     def test_locked_policy_injected(self, runtime):
@@ -182,6 +204,40 @@ class TestAgentNode:
         (note,) = update["notes"]
         assert "broken build" in note and "attempt 2" in note
 
+    def test_no_verdicts_branch_captures_artifact(self, runtime, fake_agents):
+        fake_agents.set("dev", [("write", "implementation-summary.md", "MARKER-DEV")])
+        update = make_agent_node(runtime, runtime.cfg.steps[0])(make_state())
+        assert update["artifacts"] == {"dev": "MARKER-DEV"}
+
+    def test_pass_verdict_captures_artifact(self, runtime, fake_agents):
+        fake_agents.set("check", [("write", "ci-fix.md", "MARKER-CHECK\nVERDICT: PASS\n")])
+        update = make_agent_node(runtime, runtime.cfg.steps[1])(make_state())
+        assert update["artifacts"] == {"check": "MARKER-CHECK\nVERDICT: PASS\n"}
+
+    def test_fail_verdict_captures_artifact(self, runtime, fake_agents):
+        fake_agents.set("check", [("write", "ci-fix.md", "MARKER-FAIL\nVERDICT: FAIL\n")])
+        update = make_agent_node(runtime, runtime.cfg.steps[1])(make_state())
+        assert update["artifacts"] == {"check": "MARKER-FAIL\nVERDICT: FAIL\n"}
+
+    def test_unverifiable_verdict_captures_artifact(self, runtime, fake_agents):
+        step = make_cfg([
+            {"name": "qa", "agent": "qa", "artifact": "qa-report.md",
+             "verdicts": {"pass": "PASS", "fail": "FAIL",
+                          "unverifiable": "UNVERIFIABLE"},
+             "on_pass": "success"}]).steps[0]
+        fake_agents.set("qa", [("write", "qa-report.md", "MARKER-UNVER\nVERDICT: UNVERIFIABLE\n")])
+        update = make_agent_node(runtime, step)(make_state())
+        assert update["artifacts"] == {"qa": "MARKER-UNVER\nVERDICT: UNVERIFIABLE\n"}
+
+    def test_capture_error_branch_returns_no_artifacts(self, runtime, fake_agents):
+        update = make_agent_node(runtime, runtime.cfg.steps[1])(make_state())
+        assert "artifacts" not in update
+
+    def test_unclear_branch_returns_no_artifacts(self, runtime, fake_agents):
+        fake_agents.set("check", [("write", "ci-fix.md", "undecided")])
+        update = make_agent_node(runtime, runtime.cfg.steps[1])(make_state())
+        assert "artifacts" not in update
+
     def test_verdicts_merge_with_prior_steps(self, runtime, fake_agents):
         fake_agents.set("check", [("write", "ci-fix.md", "VERDICT: PASS")])
         state = make_state(step_verdicts={"dev": "pass"})
@@ -528,14 +584,11 @@ class TestBumpNode:
     def test_consumes_attempt_resets_verdicts_rebuilds_cleans(self, runtime):
         for stale in ("ci-fix.md", "implementation-summary.md", "last-error.md"):
             (runtime.state_dir / stale).write_text("stale")
-        state = make_state(attempt=1, notes=["N1"],
+        state = make_state(attempt=1, notes=["N1"], artifacts={"dev": "D1"},
                            step_verdicts={"check": "fail"})
         update = make_bump_node(runtime)(state)
-        assert update["attempt"] == 2
-        assert update["step_verdicts"] == {}
-        assert update["failed"] is False
-        assert "## Previous attempt feedback\n\nN1" in update["context"]
-        assert "## plan.md\n\nTHE PLAN" in update["context"]
+        assert update == {"attempt": 2, "step_verdicts": {}, "failed": False}
+        assert "context" not in update  # message is rebuilt per run (027)
         for stale in ("ci-fix.md", "implementation-summary.md", "last-error.md"):
             assert not (runtime.state_dir / stale).exists()
 

agentic_dev_loop-1.0.0a15/src/agentic_dev_loop/engine/seccomp/__init__.py

@@ -1,27 +0,0 @@
-"""Bundled Docker seccomp profiles (023).
-
-Docker's default seccomp profile blocks the user-namespace syscalls Chromium's
-namespace sandbox needs, which makes ``chromium.launch(chromiumSandbox=True)``
-die at the zygote under ``--cap-drop ALL``. These profiles are Docker's default
-profile with an allowlist for those userns syscalls; pass one as
-``isolation.seccomp_profile`` to swap it in.
-"""
-
-from __future__ import annotations
-
-from importlib.resources import as_file, files
-
-CHROMIUM_USERNS_PROFILE = "chromium-userns.json"
-
-
-def chromium_userns_profile_path() -> str:
-    """Host filesystem path to the bundled Chromium userns seccomp profile.
-
-    Docker's ``--security-opt seccomp=<path>`` takes a host path, so the JSON
-    must resolve to a real file. Wheels unpack to disk, so ``as_file`` returns
-    the installed path without copying.
-    """
-    traversable = files("agentic_dev_loop.engine.seccomp").joinpath(
-        CHROMIUM_USERNS_PROFILE)
-    with as_file(traversable) as path:
-        return str(path)