agentic-dev-loop 1.0.0a22__tar.gz → 1.0.0a24__tar.gz

{agentic_dev_loop-1.0.0a22/src/agentic_dev_loop.egg-info → agentic_dev_loop-1.0.0a24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a22
+Version: 1.0.0a24
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -221,6 +221,7 @@ steps:
 | `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). |
 | `lockfiles` | The pipeline's declared lockfile names (workspace-relative), injected into agent context and named by the missing-dependency fail-fast. Required (non-empty) when `deps_policy: locked` - a `locked` pipeline with no lockfiles fails fast at load. |
 | `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); `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). |
 
 ### Secrets (`secrets:`) - refs only, never values
 
@@ -305,6 +306,20 @@ steps:
   everywhere. Reserve it for stages that need it (QA, integration). The
   residual risks are documented in [docs/setup.md](docs/setup.md).
 
+### Sync-back conflicts (host edits during a run)
+
+Only declared-`rw` paths sync back to the real repo after a step. If the host
+also edits a declared-`rw` path while the step is running, sync-back prints
+`[isolation] sync-back conflict: ...` and raises `AE-SBX-016`; the host's
+version wins, the baseline is re-snapshotted, and the next step (even
+`echo hello`) runs clean instead of re-raising forever. For append-style logs
+edited by both sides (an audit log, say), declare them in the top-level
+`merge_on_conflict:` list: those paths are union-merged - the host keeps its
+lines, the sandbox's new lines are appended in order, both sides converge, and
+the run continues with `[isolation] merged concurrent edits: ...` on the
+console.
+
+
 ## Dependency policy (locked by default)
 
 The supply-chain dial is a pipeline-level `deps_policy:` field, **locked by

{agentic_dev_loop-1.0.0a22 → agentic_dev_loop-1.0.0a24}/README.md

@@ -179,6 +179,7 @@ steps:
 | `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). |
 | `lockfiles` | The pipeline's declared lockfile names (workspace-relative), injected into agent context and named by the missing-dependency fail-fast. Required (non-empty) when `deps_policy: locked` - a `locked` pipeline with no lockfiles fails fast at load. |
 | `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); `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). |
 
 ### Secrets (`secrets:`) - refs only, never values
 
@@ -263,6 +264,20 @@ steps:
   everywhere. Reserve it for stages that need it (QA, integration). The
   residual risks are documented in [docs/setup.md](docs/setup.md).
 
+### Sync-back conflicts (host edits during a run)
+
+Only declared-`rw` paths sync back to the real repo after a step. If the host
+also edits a declared-`rw` path while the step is running, sync-back prints
+`[isolation] sync-back conflict: ...` and raises `AE-SBX-016`; the host's
+version wins, the baseline is re-snapshotted, and the next step (even
+`echo hello`) runs clean instead of re-raising forever. For append-style logs
+edited by both sides (an audit log, say), declare them in the top-level
+`merge_on_conflict:` list: those paths are union-merged - the host keeps its
+lines, the sandbox's new lines are appended in order, both sides converge, and
+the run continues with `[isolation] merged concurrent edits: ...` on the
+console.
+
+
 ## Dependency policy (locked by default)
 
 The supply-chain dial is a pipeline-level `deps_policy:` field, **locked by

{agentic_dev_loop-1.0.0a22 → agentic_dev_loop-1.0.0a24}/pyproject.toml

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

@@ -446,6 +446,10 @@ class PipelineConfig(BaseModel):
     # "no sync-back excludes".
     caches: list[str] = []
     sync_excludes: list[str] = []
+    # 029: append-style logs that sync-back union-merges on a concurrent
+    # edit instead of raising. Same declared-path vocabulary as
+    # ``sync_excludes:``.
+    merge_on_conflict: list[str] = []
 
     @field_validator("deps_policy")
     @classmethod
@@ -460,7 +464,7 @@ class PipelineConfig(BaseModel):
     def _coerce_lockfiles(cls, v: Any) -> Any:
         return [v] if isinstance(v, str) else v
 
-    @field_validator("caches", "sync_excludes", mode="before")
+    @field_validator("caches", "sync_excludes", "merge_on_conflict", mode="before")
     @classmethod
     def _coerce_declared_paths(cls, v: Any) -> Any:
         return [v] if isinstance(v, str) else v
@@ -475,6 +479,11 @@ class PipelineConfig(BaseModel):
     def _valid_sync_excludes(cls, v: list[str]) -> list[str]:
         return [_validate_declared_path(c, allow_wildcards=True) for c in v]
 
+    @field_validator("merge_on_conflict")
+    @classmethod
+    def _valid_merge_on_conflict(cls, v: list[str]) -> list[str]:
+        return [_validate_declared_path(m, allow_wildcards=True) for m in v]
+
     @field_validator("secrets", mode="before")
     @classmethod
     def _reject_value_shaped_refs(cls, v: Any) -> Any:
@@ -579,6 +588,32 @@ class PipelineConfig(BaseModel):
                         f"{('/'.join(cp))!r}")
         return self
 
+    @model_validator(mode="after")
+    def _merge_avoid_excludes_and_caches(self) -> "PipelineConfig":
+        """029: a literal merge_on_conflict entry equal to or under a literal
+        sync_excludes entry or a literal caches entry is redundant - excluded
+        and cached paths never sync, so they can never conflict. Wildcard
+        merge entries are skipped (their overlap is fuzzy, 028 parity)."""
+        cache_parts = [relative_parts(c) for c in self.caches if relative_parts(c)]
+        exclude_parts = [relative_parts(e) for e in self.sync_excludes
+                         if not _has_wildcards(e) and relative_parts(e)]
+        for merge in self.merge_on_conflict:
+            if _has_wildcards(merge):
+                continue
+            mp = relative_parts(merge)
+            for cp in cache_parts:
+                if mp[:len(cp)] == cp:
+                    raise ValueError(
+                        f"merge_on_conflict entry {merge!r} is redundant: it is "
+                        f"already excluded as declared cache {('/'.join(cp))!r}")
+            for ep in exclude_parts:
+                if mp[:len(ep)] == ep:
+                    raise ValueError(
+                        f"merge_on_conflict entry {merge!r} is redundant: it is "
+                        f"already excluded by sync_excludes entry "
+                        f"{('/'.join(ep))!r}")
+        return self
+
     @model_validator(mode="after")
     def _sandbox_venv_not_declared_cache(self) -> "PipelineConfig":
         """028: the sandbox venv is engine infrastructure, never author data.

{agentic_dev_loop-1.0.0a22 → agentic_dev_loop-1.0.0a24}/src/agentic_dev_loop/engine/isolation.py

@@ -43,7 +43,7 @@ from .mounts import Mount, MountSet
 from .proc import needs_shell, split_command
 from .seccomp import resolve_seccomp_profile
 from .step_workspace import StepWorkspace
-from .sync_back import SyncBackReport, _snapshot, sync_back
+from .sync_back import SyncBackReport, _snapshot, merge_append_only, sync_back
 
 # ---------------------------------------------------------------------------
 # Constants (KD-2 / ID-4)
@@ -791,7 +791,8 @@ class DockerBackend(Sandbox):
                  seccomp_profile: str | None = None,
                  export_root: str | None = None,
                  cache_mounts: list[tuple[str, str, str]] | None = None,
-                 sync_excludes: list[str] | None = None):
+                 sync_excludes: list[str] | None = None,
+                 merge_on_conflict: list[str] | None = None):
         self._image = image
         self._workspace = workspace
         self._iso_state_dir = Path(iso_state_dir)  # host-only (audit)
@@ -818,6 +819,9 @@ class DockerBackend(Sandbox):
         # 028: run-wide sync-back excludes (scratch paths - skipped from both
         # the export copy and every snapshot).
         self._sync_excludes = list(sync_excludes or ())
+        # 029: append-style logs union-merged on a concurrent-edit conflict
+        # instead of raising (host wins, export-only lines appended).
+        self._merge_on_conflict = list(merge_on_conflict or ())
         self._baseline: dict[str, str] = {}
         # The profile-keyed pool (D-1/BR-10): profile key -> running container.
         self._pool: dict[tuple[str, bool], _ProfileContainer] = {}
@@ -1072,19 +1076,75 @@ class DockerBackend(Sandbox):
                                  egress_policy=policy, proxy=proxy,
                                  started=True)
 
+    def _reset_export_to_host(self, rel: str) -> None:
+        """Absorb one hard-conflict path: the host wins, so the export is
+        reset to match it. A host-side deletion removes the export file; any
+        other host state is copied back (preserving symlinks)."""
+        host_path = Path(self._workspace) / rel
+        export_path = Path(self._export_root) / rel
+        if not host_path.exists() and not host_path.is_symlink():
+            export_path.unlink(missing_ok=True)
+            return
+        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:
         """Sync declared-rw export changes back to the real repo (BR-4/F1),
-        git-aware, host-side, with the sandbox step already complete. A
-        conflict (the real repo changed underneath) is a loud failure."""
+        git-aware, host-side, with the sandbox step already complete.
+
+        029: a conflict on a declared ``merge_on_conflict:`` path is
+        union-merged (host wins, export-only lines appended) and does not
+        raise. A conflict on any other path - including a declared merge path
+        one side deleted - is announced, absorbed (the host wins and the
+        export is reset to it), and then still raises AE-SBX-016 scoped to
+        those hard paths, so the next sync-back runs clean. Merge paths are
+        union-merged first, before any hard-conflict raise."""
         report: SyncBackReport = sync_back(
             self._export_root, self._workspace, list(mount_set.rw_paths()),
             baseline=self._baseline, step_id=None,
-            cache_paths=self._cache_paths, excludes=self._sync_excludes)
+            cache_paths=self._cache_paths, excludes=self._sync_excludes,
+            merge_on_conflict=self._merge_on_conflict)
+
+        # 029 step 2: union-merge declared merge paths first, so a mixed
+        # merge+hard conflict still converges the append-style logs before
+        # the hard paths raise.
+        for rel in report.merged_paths:
+            host_path = Path(self._workspace) / rel
+            export_path = Path(self._export_root) / rel
+            host_text = host_path.read_text(encoding="utf-8")
+            export_text = export_path.read_text(encoding="utf-8")
+            merged = merge_append_only(host_text, export_text)
+            appended = len(merged.splitlines()) - len(host_text.splitlines())
+            host_path.write_text(merged, encoding="utf-8")
+            export_path.write_text(merged, encoding="utf-8")
+            _announce(
+                f"merged concurrent edits: {rel} "
+                f"({appended} sandbox lines appended)")
+            append_audit_record(self._iso_state_dir, {
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "event": "sync_back_merge",
+                "path": rel,
+                "appended_lines": appended,
+            })
+
         if report.conflicts:
+            # fix 1 + fix 2: absorb the divergence once (host wins on every
+            # hard path, reset the export to match) and announce before the
+            # raise, so the next exec - even `echo hello` - runs clean.
+            for rel in report.conflicts:
+                self._reset_export_to_host(rel)
+            _announce(
+                f"sync-back conflict: {', '.join(report.conflicts)} - the "
+                "workspace changed underneath; edits to these paths will "
+                "not sync")
+            self._baseline = _snapshot(Path(self._export_root),
+                                       self._cache_paths,
+                                       self._sync_excludes)
             raise SandboxError(
                 f"AE-SBX-016: sync-back conflict in "
                 f"{', '.join(report.conflicts)} - the real repo changed "
-                f"underneath; resolve before retrying (BR-4.4)")
+                f"underneath; edits to these paths will not sync (BR-4.4)")
+
         self._baseline = _snapshot(Path(self._export_root),
                                    self._cache_paths,
                                    self._sync_excludes)
@@ -1092,6 +1152,7 @@ class DockerBackend(Sandbox):
             "timestamp": datetime.now(timezone.utc).isoformat(),
             "event": "sync_back",
             "synced_paths": list(report.synced_paths),
+            "merged_paths": list(report.merged_paths),
         })
 
     def close(self) -> None:
@@ -1307,6 +1368,16 @@ def resolve_image_ref(image: str, environ: Mapping[str, str] | None = None) -> s
     return image
 
 
+_MODULE_TAG = __name__.rsplit(".", 1)[-1]
+
+
+def _announce(msg: str) -> None:
+    """One-line console progress note for the eager startup phases. The tag is
+    derived from the emitting module's own name (what a logging library's
+    name field would record), never hardcoded."""
+    print(f"[{_MODULE_TAG}] {msg}", flush=True)
+
+
 def startup_sandbox(cfg: PipelineConfig, *, workspace: Path,
                     state_dir: str | Path,
                     runner: CommandRunner | None = None,
@@ -1323,6 +1394,7 @@ def startup_sandbox(cfg: PipelineConfig, *, workspace: Path,
     direct Sandbox API (DockerBackend without an export + requests carrying
     ``mount_set=None``), which is integration-tests-only."""
     seccomp_profile = resolved_seccomp_profile(cfg)
+    _announce("probing docker daemon...")
     probe_docker(runner)
     profile = resolve_effective_profile(cfg.isolation)
     image = resolve_image_ref(profile.image)
@@ -1343,15 +1415,18 @@ def startup_sandbox(cfg: PipelineConfig, *, workspace: Path,
             cache_paths.append(SANDBOX_VENV_DIR)
     for cache in cfg.caches:
         (workspace / cache).mkdir(parents=True, exist_ok=True)
+    _announce("materialising workspace export...")
     ws = StepWorkspace.materialise(
         workspace, cache_paths, sys.platform, export_root,
         state_dir=str(state_dir), excludes=list(cfg.sync_excludes))
     export_root = str(ws.export_root)
     cache_mounts = ws.mount_points()[1:]  # skip the export root itself
+    _announce(f"export ready at {export_root}")
     # Repair console-script shebangs that bake a previous run's dead export
     # path (028): a venv built by export A must execute its ``bin/*`` scripts
     # when mounted into export B.
     venv_dir = Path(sandbox_venv_dir) if sandbox_venv_dir else workspace / SANDBOX_VENV_DIR
+    _announce("checking venv shebangs")
     repair_venv_shebangs(venv_dir, state_dir=state_dir, export_root=export_root)
 
     backend = DockerBackend(
@@ -1359,12 +1434,19 @@ def startup_sandbox(cfg: PipelineConfig, *, workspace: Path,
         profile=profile, runner=runner, network=needs_network,
         sandbox_venv_dir=sandbox_venv_dir, seccomp_profile=seccomp_profile,
         export_root=export_root, cache_mounts=cache_mounts,
-        sync_excludes=list(cfg.sync_excludes))
+        sync_excludes=list(cfg.sync_excludes),
+        merge_on_conflict=list(cfg.merge_on_conflict))
+    _announce(f"preparing sandbox image {image} (first pull can take a while)")
     backend.ensure_image()
+    _announce("sandbox image ready")
+    _announce("starting execution container...")
     backend.create_execution_container()
+    _announce("execution container started")
     if refresh is None:
         refresh = bool(cfg.isolation and cfg.isolation.refresh)
     for setup_cmd, stamp_key in _declared_setups(cfg, workspace):
+        _announce(f"provisioning setup (stamp {stamp_key[:8]})")
         backend.provision(setup_cmd, stamp_key, str(iso_state_dir / "stamps"),
                           force=refresh)
+    _announce("sandbox ready")
     return backend

{agentic_dev_loop-1.0.0a22 → agentic_dev_loop-1.0.0a24}/src/agentic_dev_loop/engine/sync_back.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 import hashlib
 import os
 import shutil
+from collections import Counter
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
@@ -43,10 +44,38 @@ class SyncBackReport:
 
     synced_paths: tuple[str, ...]
     conflicts: tuple[str, ...]
+    merged_paths: tuple[str, ...] = ()
     step_id: str | None = None
     timestamp: str = ""
 
 
+def merge_append_only(host_text: str, export_text: str) -> str:
+    """Union-merge two append-style logs (029): the host file wins for every
+    line it already contains (host order is preserved) and each export-only
+    line is appended in export order. Nothing is ever deleted, so both sides
+    converge on the line-level union; identical sides return the host text
+    unchanged.
+
+    Export-only is a multiset difference against the host, not a naive
+    ``difflib`` opcode filter: the common both-appended-tail case is a
+    ``replace`` opcode there, and a union must keep both tails."""
+    host_lines = host_text.splitlines()
+    export_lines = export_text.splitlines()
+    remaining: Counter[str] = Counter(host_lines)
+    extra: list[str] = []
+    for line in export_lines:
+        if remaining[line]:
+            remaining[line] -= 1
+        else:
+            extra.append(line)
+    if not extra:
+        return host_text
+    merged = "\n".join(host_lines + extra)
+    if host_text.endswith("\n") or export_text.endswith("\n"):
+        merged += "\n"
+    return merged
+
+
 def _parts(rel: str) -> tuple[str, ...]:
     """Normalise a repo-relative path into its non-empty, non-``.`` segments."""
     return tuple(seg for seg in rel.replace("\\", "/").split("/")
@@ -157,14 +186,20 @@ def sync_back(export_root: str | Path, real_repo: str | Path,
               baseline: Mapping[str, str] | None = None,
               step_id: str | None = None,
               cache_paths: list[str] | tuple[str, ...] = (),
-              excludes: list[str] | tuple[str, ...] = ()) -> SyncBackReport:
+              excludes: list[str] | tuple[str, ...] = (),
+              merge_on_conflict: list[str] | tuple[str, ...] = ()) -> SyncBackReport:
     """Diff-copy declared-rw export changes into the real repo (ID-5).
 
     A conflict - a declared-rw path changed in the export AND in the real repo
     since materialisation - is a loud failure (BR-4.4): the report carries the
-    conflicts and nothing is copied. Otherwise declared-rw adds/modifies copy
-    host-side and declared-rw deletions remove host-side; ``.git``, the
-    bind-mounted caches, and declared sync-excludes are never touched."""
+    conflicts and nothing is copied. A ``merge_on_conflict:`` path (029) is
+    partitioned across every change kind: a both-sides-present conflict is
+    reported in ``merged_paths`` for the caller to union-merge, while a
+    one-side deletion (``added``/``deleted``) stays a hard conflict so the
+    append-only log is never silently resurrected or erased. Non-conflicting
+    adds/modifies still copy and deletions still remove host-side when no
+    hard conflict remains. ``.git``, the bind-mounted caches, and declared
+    sync-excludes are never touched."""
     export_root = Path(export_root)
     real_repo = Path(real_repo)
     baseline = dict(baseline or {})
@@ -191,10 +226,39 @@ def sync_back(export_root: str | Path, real_repo: str | Path,
             else:
                 changes[rel] = "modified"
 
-    plan = plan_sync_back(changes, declared_rw, cache_paths, excludes)
-    if plan.conflicts:
+    merge_specs = list(merge_on_conflict or ())
+    merged_paths: list[str] = []
+    hard_conflicts: list[str] = []
+    plan_changes: dict[str, str] = {}
+    for rel, kind in changes.items():
+        if path_excluded(rel, merge_specs):
+            # Declared merge path (029). Union-merge only handles both sides
+            # present; a one-side deletion stays a hard conflict (raise +
+            # absorb, host wins) so a concurrent host/export delete can never
+            # silently resurrect or erase the append-only log.
+            if kind == "conflict":
+                merged_paths.append(rel)
+            elif kind in ("added", "deleted"):
+                hard_conflicts.append(rel)
+            else:
+                plan_changes[rel] = kind
+        elif kind == "conflict":
+            hard_conflicts.append(rel)
+        else:
+            plan_changes[rel] = kind
+
+    plan = plan_sync_back(plan_changes, declared_rw, cache_paths, excludes)
+    merged_paths = tuple(sorted(merged_paths))
+    hard_conflicts = tuple(sorted(hard_conflicts))
+
+    # A hard (non-merge) conflict keeps the BR-4.4 loud failure and the
+    # copy/delete stays atomic: nothing non-merge copies or deletes when one
+    # remains. Merge paths are still reported so the caller union-merges them
+    # first (029 step order: merge before the hard-conflict raise).
+    if hard_conflicts:
         return SyncBackReport(
-            synced_paths=(), conflicts=plan.conflicts, step_id=step_id,
+            synced_paths=(), conflicts=hard_conflicts,
+            merged_paths=merged_paths, step_id=step_id,
             timestamp=datetime.now(timezone.utc).isoformat())
 
     for rel in plan.to_copy:
@@ -207,5 +271,5 @@ def sync_back(export_root: str | Path, real_repo: str | Path,
 
     return SyncBackReport(
         synced_paths=plan.to_copy + plan.to_delete,
-        conflicts=(), step_id=step_id,
+        conflicts=(), merged_paths=merged_paths, step_id=step_id,
         timestamp=datetime.now(timezone.utc).isoformat())

{agentic_dev_loop-1.0.0a22 → agentic_dev_loop-1.0.0a24/src/agentic_dev_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a22
+Version: 1.0.0a24
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -221,6 +221,7 @@ steps:
 | `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). |
 | `lockfiles` | The pipeline's declared lockfile names (workspace-relative), injected into agent context and named by the missing-dependency fail-fast. Required (non-empty) when `deps_policy: locked` - a `locked` pipeline with no lockfiles fails fast at load. |
 | `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); `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). |
 
 ### Secrets (`secrets:`) - refs only, never values
 
@@ -305,6 +306,20 @@ steps:
   everywhere. Reserve it for stages that need it (QA, integration). The
   residual risks are documented in [docs/setup.md](docs/setup.md).
 
+### Sync-back conflicts (host edits during a run)
+
+Only declared-`rw` paths sync back to the real repo after a step. If the host
+also edits a declared-`rw` path while the step is running, sync-back prints
+`[isolation] sync-back conflict: ...` and raises `AE-SBX-016`; the host's
+version wins, the baseline is re-snapshotted, and the next step (even
+`echo hello`) runs clean instead of re-raising forever. For append-style logs
+edited by both sides (an audit log, say), declare them in the top-level
+`merge_on_conflict:` list: those paths are union-merged - the host keeps its
+lines, the sandbox's new lines are appended in order, both sides converge, and
+the run continues with `[isolation] merged concurrent edits: ...` on the
+console.
+
+
 ## Dependency policy (locked by default)
 
 The supply-chain dial is a pipeline-level `deps_policy:` field, **locked by

{agentic_dev_loop-1.0.0a22 → agentic_dev_loop-1.0.0a24}/src/agentic_dev_loop.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ src/agentic_dev_loop/viz/__init__.py
 src/agentic_dev_loop/viz/__main__.py
 src/agentic_dev_loop/viz/server.py
 tests/test_028_declared_caches.py
+tests/test_029_merge_on_conflict.py
 tests/test_actions.py
 tests/test_agents.py
 tests/test_aidlc.py

agentic_dev_loop-1.0.0a24/tests/test_029_merge_on_conflict.py

@@ -0,0 +1,97 @@
+"""029: ``merge_on_conflict:`` config surface and validation.
+
+Top-level run-wide list of append-style logs that sync-back union-merges on a
+concurrent-edit conflict instead of raising. Same declared-path vocabulary as
+``sync_excludes:``; literals under a literal ``sync_excludes:``/``caches:``
+entry are redundant and rejected.
+"""
+
+import yaml
+import pytest
+from pydantic import ValidationError
+
+from agentic_dev_loop.core.config import load_config
+
+
+def _base() -> dict:
+    return {
+        "name": "t",
+        "llm": {"model": "m", "api_key_env": "K"},
+        "agents_dir": "agents",
+        "lockfiles": ["uv.lock"],
+        "steps": [{"name": "dev", "agent": "dev", "on_pass": "success"}],
+    }
+
+
+def _load(tmp_path, data):
+    p = tmp_path / "pipeline.yaml"
+    p.write_text(yaml.safe_dump(data))
+    return load_config(p)
+
+
+class TestCoercionAndAcceptance:
+    def test_single_string_coerced_to_list(self, tmp_path):
+        data = _base()
+        data["merge_on_conflict"] = "aidlc-docs/audit.md"
+        assert _load(tmp_path, data).merge_on_conflict == ["aidlc-docs/audit.md"]
+
+    def test_defaults_empty(self, tmp_path):
+        assert _load(tmp_path, _base()).merge_on_conflict == []
+
+    def test_wildcards_accepted(self, tmp_path):
+        data = _base()
+        data["merge_on_conflict"] = ["**/audit.md", "*.log"]
+        assert _load(tmp_path, data).merge_on_conflict == ["**/audit.md", "*.log"]
+
+
+class TestRejected:
+    def test_traversal(self, tmp_path):
+        data = _base()
+        data["merge_on_conflict"] = ["../escape"]
+        with pytest.raises(ValidationError, match="traversal"):
+            _load(tmp_path, data)
+
+    def test_absolute(self, tmp_path):
+        data = _base()
+        data["merge_on_conflict"] = ["/abs"]
+        with pytest.raises(ValidationError, match="repo-relative"):
+            _load(tmp_path, data)
+
+    def test_git(self, tmp_path):
+        data = _base()
+        data["merge_on_conflict"] = [".git/config"]
+        with pytest.raises(ValidationError, match=r"\.git"):
+            _load(tmp_path, data)
+
+    def test_host_only(self, tmp_path):
+        data = _base()
+        data["merge_on_conflict"] = [".venv"]
+        with pytest.raises(ValidationError, match="host-only"):
+            _load(tmp_path, data)
+
+    def test_under_sync_excludes_redundant(self, tmp_path):
+        data = _base()
+        data["sync_excludes"] = ["scratch"]
+        data["merge_on_conflict"] = ["scratch/audit.md"]
+        with pytest.raises(ValidationError, match="redundant"):
+            _load(tmp_path, data)
+
+    def test_under_cache_redundant(self, tmp_path):
+        data = _base()
+        data["caches"] = ["node_modules"]
+        data["merge_on_conflict"] = ["node_modules/audit.md"]
+        with pytest.raises(ValidationError, match="redundant"):
+            _load(tmp_path, data)
+
+    def test_wildcard_overlap_not_rejected(self, tmp_path):
+        """Wildcard overlap is fuzzy, never a hard contradiction (028 parity)."""
+        data = _base()
+        data["sync_excludes"] = ["**/bin/**"]
+        data["caches"] = ["qa"]
+        data["merge_on_conflict"] = ["**/audit.md"]
+        assert _load(tmp_path, data).merge_on_conflict == ["**/audit.md"]
+
+    def test_clear_entry_accepted(self, tmp_path):
+        data = _base()
+        data["merge_on_conflict"] = ["aidlc-docs/audit.md"]
+        assert _load(tmp_path, data).merge_on_conflict == ["aidlc-docs/audit.md"]

{agentic_dev_loop-1.0.0a22 → agentic_dev_loop-1.0.0a24}/tests/test_graph.py

@@ -9,7 +9,6 @@ import argparse
 import queue
 import sqlite3
 import subprocess
-import time
 from pathlib import Path
 
 import pytest
@@ -353,21 +352,6 @@ class TestCommandStep:
         second_dev = fake_agents.messages_for("dev")[1]
         assert "test output" in second_dev and "attempt 1" in second_dev
 
-    def test_timeout_exhausts_run_and_kills_process_group(self, repo,
-                                                          fake_agents):
-        yaml = COMMAND_STAGE_YAML.replace(
-            "    command: python -c \"import sys; import pathlib; print('test output'); sys.exit(0 if pathlib.Path('.pr/fix.marker').exists() else 1)\"",
-            '    command: python -c "import time; time.sleep(3)"\n    timeout: 0.2')
-        self._write(repo, yaml)
-        fake_agents.set("dev", [("write", "fix.marker", "")])
-        start = time.monotonic()
-        ok, attempts = run_pipeline("commandstage.yaml", args())
-        elapsed = time.monotonic() - start
-        assert (ok, attempts) == (False, 3)
-        assert fake_agents.agents_called() == ["dev"] * 3
-        assert all("timed out" in m for m in fake_agents.messages_for("dev")[1:])
-        assert elapsed < 5.0  # killpg cut the 3s sleeps short
-
     def test_fail_forever_with_cli_max_attempts(self, repo, fake_agents):
         yaml = COMMAND_STAGE_YAML.replace(
             "sys.exit(0 if pathlib.Path('.pr/fix.marker').exists() else 1)",