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

{agentic_dev_loop-1.0.0a23/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.0a23
+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.0a23 → 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.0a23 → 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.0a23"
+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.0a23 → 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.0a23 → 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:
@@ -1373,7 +1434,8 @@ 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")

{agentic_dev_loop-1.0.0a23 → 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.0a23 → 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.0a23
+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.0a23 → 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.0a23 → agentic_dev_loop-1.0.0a24}/tests/test_isolation.py

@@ -1609,6 +1609,202 @@ class TestUnit5RuntimeEnforcement:
             backend.close()
 
 
+    def test_sync_back_merge_path_converges_and_no_raise(self, tmp_path, capsys):
+        """029: a conflict on a declared merge path is union-merged: host and
+        export converge, the baseline is re-snapshotted, and no raise occurs."""
+        import hashlib
+
+        ws = tmp_path / "ws"
+        (ws / "src").mkdir(parents=True)
+        (ws / "src" / "audit.md").write_text("base\nhost-line\n")
+        export = tmp_path / "export"
+        (export / "src").mkdir(parents=True)
+        (export / "src" / "audit.md").write_text("base\nexport-line\n")
+        runner = FakeRunner(ok("cid"), ok(""))
+        backend = DockerBackend(
+            image="img@sha256:abc", workspace=str(ws),
+            iso_state_dir=str(tmp_path / "state"),
+            profile=EffectiveProfile(True, True, True, True, True,
+                                     "img@sha256:abc", "4g", 2.0),
+            runner=runner, network=False, export_root=str(export),
+            merge_on_conflict=["src/audit.md"])
+        backend._baseline = {"src/audit.md": hashlib.sha256(b"base\n").hexdigest()}
+        ms = resolve_mount_set([MountSpec(path="src", mode="rw")])
+        req = SandboxExecutionRequest(argv=["echo", "hi"], cwd=str(export),
+                                      env={}, network=False, mount_set=ms,
+                                      egress_policy=EgressPolicy())
+        try:
+            backend.run(req)
+            merged = "base\nhost-line\nexport-line\n"
+            assert (ws / "src" / "audit.md").read_text() == merged
+            assert (export / "src" / "audit.md").read_text() == merged
+            out = capsys.readouterr().out
+            assert ("[isolation] merged concurrent edits: src/audit.md "
+                    "(1 sandbox lines appended)") in out
+            audit = (tmp_path / "state" / "sandbox-audit.jsonl").read_text()
+            assert "sync_back_merge" in audit
+            assert "src/audit.md" in audit
+            # the baseline was re-snapshotted: a subsequent sync is clean
+            backend.run(req)
+        finally:
+            backend.close()
+
+    def test_sync_back_conflict_absorbs_baseline_for_next_sync(self, tmp_path,
+                                                              capsys):
+        """029 fixes 1+2: a hard conflict announces once, discards the
+        conflicted exec's edit (host wins), re-snapshots the baseline, and the
+        next sync-back with no new changes runs clean."""
+        import hashlib
+
+        ws = tmp_path / "ws"
+        (ws / "src").mkdir(parents=True)
+        (ws / "src" / "a.py").write_text("external")
+        export = tmp_path / "export"
+        (export / "src").mkdir(parents=True)
+        (export / "src" / "a.py").write_text("agent")
+        runner = FakeRunner(ok("cid"), ok(""))
+        backend = DockerBackend(
+            image="img@sha256:abc", workspace=str(ws),
+            iso_state_dir=str(tmp_path / "state"),
+            profile=EffectiveProfile(True, True, True, True, True,
+                                     "img@sha256:abc", "4g", 2.0),
+            runner=runner, network=False, export_root=str(export))
+        backend._baseline = {"src/a.py": hashlib.sha256(b"orig").hexdigest()}
+        ms = resolve_mount_set([MountSpec(path="src", mode="rw")])
+        req = SandboxExecutionRequest(argv=["echo", "hi"], cwd=str(export),
+                                      env={}, network=False, mount_set=ms,
+                                      egress_policy=EgressPolicy())
+        try:
+            with pytest.raises(SandboxError, match="AE-SBX-016"):
+                backend.run(req)
+            assert (ws / "src" / "a.py").read_text() == "external"
+            assert (export / "src" / "a.py").read_text() == "external"
+            out = capsys.readouterr().out
+            assert ("[isolation] sync-back conflict: src/a.py - the workspace "
+                    "changed underneath; edits to these paths will not sync") in out
+            backend.run(req)  # absorbed: no new changes, no raise
+        finally:
+            backend.close()
+
+    def test_conflict_raise_lists_only_hard_paths(self, tmp_path, capsys):
+        """029: a mixed merge+hard conflict merges the append-style log first
+        and then raises AE-SBX-016 scoped to the hard paths only."""
+        import hashlib
+
+        ws = tmp_path / "ws"
+        (ws / "src").mkdir(parents=True)
+        (ws / "src" / "audit.md").write_text("base\nhost-line\n")
+        (ws / "src" / "b.py").write_text("external-b")
+        export = tmp_path / "export"
+        (export / "src").mkdir(parents=True)
+        (export / "src" / "audit.md").write_text("base\nexport-line\n")
+        (export / "src" / "b.py").write_text("agent-b")
+        runner = FakeRunner(ok("cid"), ok(""))
+        backend = DockerBackend(
+            image="img@sha256:abc", workspace=str(ws),
+            iso_state_dir=str(tmp_path / "state"),
+            profile=EffectiveProfile(True, True, True, True, True,
+                                     "img@sha256:abc", "4g", 2.0),
+            runner=runner, network=False, export_root=str(export),
+            merge_on_conflict=["src/audit.md"])
+        backend._baseline = {
+            "src/audit.md": hashlib.sha256(b"base\n").hexdigest(),
+            "src/b.py": hashlib.sha256(b"orig-b").hexdigest(),
+        }
+        ms = resolve_mount_set([MountSpec(path="src", mode="rw")])
+        req = SandboxExecutionRequest(argv=["echo", "hi"], cwd=str(export),
+                                      env={}, network=False, mount_set=ms,
+                                      egress_policy=EgressPolicy())
+        try:
+            with pytest.raises(SandboxError) as exc:
+                backend.run(req)
+            assert "src/b.py" in str(exc.value)
+            assert "audit.md" not in str(exc.value)
+            merged = "base\nhost-line\nexport-line\n"
+            assert (ws / "src" / "audit.md").read_text() == merged
+            assert (export / "src" / "audit.md").read_text() == merged
+            out = capsys.readouterr().out
+            assert ("[isolation] merged concurrent edits: src/audit.md "
+                    "(1 sandbox lines appended)") in out
+            assert ("[isolation] sync-back conflict: src/b.py - the workspace "
+                    "changed underneath; edits to these paths will not sync") in out
+        finally:
+            backend.close()
+
+
+    def test_merge_path_host_deleted_raises_and_absorb_removes_export(
+            self, tmp_path, capsys):
+        """029: a host-deleted declared merge path is a hard conflict - the
+        host wins, the export copy is unlinked, and AE-SBX-016 raises once."""
+        import hashlib
+
+        ws = tmp_path / "ws"
+        (ws / "src").mkdir(parents=True)
+        export = tmp_path / "export"
+        (export / "src").mkdir(parents=True)
+        (export / "src" / "audit.md").write_text("export\n")
+        runner = FakeRunner(ok("cid"), ok(""))
+        backend = DockerBackend(
+            image="img@sha256:abc", workspace=str(ws),
+            iso_state_dir=str(tmp_path / "state"),
+            profile=EffectiveProfile(True, True, True, True, True,
+                                     "img@sha256:abc", "4g", 2.0),
+            runner=runner, network=False, export_root=str(export),
+            merge_on_conflict=["src/audit.md"])
+        backend._baseline = {"src/audit.md": hashlib.sha256(b"base\n").hexdigest()}
+        ms = resolve_mount_set([MountSpec(path="src", mode="rw")])
+        req = SandboxExecutionRequest(argv=["echo", "hi"], cwd=str(export),
+                                      env={}, network=False, mount_set=ms,
+                                      egress_policy=EgressPolicy())
+        try:
+            with pytest.raises(SandboxError, match="AE-SBX-016"):
+                backend.run(req)
+            assert not (ws / "src" / "audit.md").exists()
+            assert not (export / "src" / "audit.md").exists()
+            out = capsys.readouterr().out
+            assert ("[isolation] sync-back conflict: src/audit.md - the "
+                    "workspace changed underneath") in out
+            backend.run(req)  # absorbed: no new changes, no raise
+        finally:
+            backend.close()
+
+    def test_merge_path_export_deleted_raises_and_absorb_restores_export(
+            self, tmp_path, capsys):
+        """029: an export-deleted declared merge path is a hard conflict - the
+        host wins, the export copy is restored, and AE-SBX-016 raises once."""
+        import hashlib
+
+        ws = tmp_path / "ws"
+        (ws / "src").mkdir(parents=True)
+        (ws / "src" / "audit.md").write_text("host\n")
+        export = tmp_path / "export"
+        (export / "src").mkdir(parents=True)
+        runner = FakeRunner(ok("cid"), ok(""))
+        backend = DockerBackend(
+            image="img@sha256:abc", workspace=str(ws),
+            iso_state_dir=str(tmp_path / "state"),
+            profile=EffectiveProfile(True, True, True, True, True,
+                                     "img@sha256:abc", "4g", 2.0),
+            runner=runner, network=False, export_root=str(export),
+            merge_on_conflict=["src/audit.md"])
+        backend._baseline = {"src/audit.md": hashlib.sha256(b"base\n").hexdigest()}
+        ms = resolve_mount_set([MountSpec(path="src", mode="rw")])
+        req = SandboxExecutionRequest(argv=["echo", "hi"], cwd=str(export),
+                                      env={}, network=False, mount_set=ms,
+                                      egress_policy=EgressPolicy())
+        try:
+            with pytest.raises(SandboxError, match="AE-SBX-016"):
+                backend.run(req)
+            assert (ws / "src" / "audit.md").read_text() == "host\n"
+            assert (export / "src" / "audit.md").read_text() == "host\n"
+            out = capsys.readouterr().out
+            assert ("[isolation] sync-back conflict: src/audit.md - the "
+                    "workspace changed underneath") in out
+            backend.run(req)  # absorbed: no new changes, no raise
+        finally:
+            backend.close()
+
+
 class TestDeclaredCachesAndSyncExcludes:
     """028: ``caches:``/``sync_excludes:`` wiring into startup and the
     engine's removal of the hardcoded cache whitelist."""

{agentic_dev_loop-1.0.0a23 → agentic_dev_loop-1.0.0a24}/tests/test_sync_back.py

@@ -6,7 +6,7 @@ import os
 
 import pytest
 
-from agentic_dev_loop.engine.sync_back import sync_back
+from agentic_dev_loop.engine.sync_back import merge_append_only, sync_back
 
 
 def _digest(p):
@@ -222,3 +222,126 @@ class TestSyncExcludes:
         assert a.to_copy == ("src/a.py",)
         assert a.to_delete == ()
         assert a.conflicts == ()
+
+
+class TestMergeAppendOnly:
+    def test_identical_sides_are_noop(self):
+        assert merge_append_only("a\nb\n", "a\nb\n") == "a\nb\n"
+
+    def test_host_only_lines_survive(self):
+        assert merge_append_only("a\nb\nhost\n", "a\nb\n") == "a\nb\nhost\n"
+
+    def test_export_only_lines_appended_in_order(self):
+        assert merge_append_only(
+            "a\nb\n", "a\nb\nexport1\nexport2\n") == "a\nb\nexport1\nexport2\n"
+
+    def test_both_appended_tails_union(self):
+        assert merge_append_only(
+            "a\nb\nhost-new\n", "a\nb\nexport-new\n") == "a\nb\nhost-new\nexport-new\n"
+
+    def test_deletions_never_applied_and_duplicates_kept(self):
+        assert merge_append_only("a\nb\n", "a\nb\na\n") == "a\nb\na\n"
+
+    def test_empty_host_is_export_text(self):
+        assert merge_append_only("", "a\n") == "a\n"
+
+    def test_no_export_only_lines_returns_host_verbatim(self):
+        host = "a\nb"
+        assert merge_append_only(host, "a\nb") is host
+
+
+class TestMergeOnConflictPartition:
+    def test_merge_conflict_partitioned_and_non_conflicting_copied(self, tmp_path):
+        ws = _workspace(tmp_path)
+        exp = _export(tmp_path, ws)
+        (ws / "src" / "audit.md").write_text("base\nhost-line\n")
+        (exp / "src" / "audit.md").write_text("base\nexport-line\n")
+        (exp / "src" / "a.py").write_text("changed-a")
+        baseline = {"src/audit.md": hashlib.sha256(b"base\n").hexdigest(),
+                    "src/a.py": _digest(ws / "src" / "a.py")}
+        report = sync_back(exp, ws, ["src"], baseline=baseline,
+                           merge_on_conflict=["src/audit.md"])
+        assert report.conflicts == ()
+        assert report.merged_paths == ("src/audit.md",)
+        assert "src/a.py" in report.synced_paths
+        assert (ws / "src" / "a.py").read_text() == "changed-a"
+        # merge paths are merged by the engine, not by the planner
+        assert (ws / "src" / "audit.md").read_text() == "base\nhost-line\n"
+        assert (exp / "src" / "audit.md").read_text() == "base\nexport-line\n"
+
+    def test_non_merge_conflict_still_loud_and_atomic(self, tmp_path):
+        ws = _workspace(tmp_path)
+        exp = _export(tmp_path, ws)
+        (exp / "src" / "a.py").write_text("agent-change")
+        (ws / "src" / "a.py").write_text("external-change")
+        baseline = {"src/a.py": hashlib.sha256(b"orig-a").hexdigest()}
+        report = sync_back(exp, ws, ["src"], baseline=baseline,
+                           merge_on_conflict=["other.md"])
+        assert report.conflicts == ("src/a.py",)
+        assert report.merged_paths == ()
+        assert report.synced_paths == ()
+
+    def test_mixed_merge_and_hard_keeps_non_merge_atomic(self, tmp_path):
+        """A hard conflict leaves the non-merge copy/delete atomic, but the
+        merge path is still reported so the caller can union-merge it first."""
+        ws = _workspace(tmp_path)
+        exp = _export(tmp_path, ws)
+        (ws / "src" / "audit.md").write_text("base\nhost-line\n")
+        (exp / "src" / "audit.md").write_text("base\nexport-line\n")
+        (exp / "src" / "b.py").write_text("agent-b")
+        (ws / "src" / "b.py").write_text("external-b")
+        baseline = {"src/audit.md": hashlib.sha256(b"base\n").hexdigest(),
+                    "src/b.py": hashlib.sha256(b"orig-b").hexdigest()}
+        report = sync_back(exp, ws, ["src"], baseline=baseline,
+                           merge_on_conflict=["src/audit.md"])
+        assert report.conflicts == ("src/b.py",)
+        assert report.merged_paths == ("src/audit.md",)
+        assert report.synced_paths == ()
+
+    def test_wildcard_merge_match(self, tmp_path):
+        ws = _workspace(tmp_path)
+        exp = _export(tmp_path, ws)
+        (ws / "src" / "build.log").write_text("base\nhost\n")
+        (exp / "src" / "build.log").write_text("base\nexport\n")
+        baseline = {"src/build.log": hashlib.sha256(b"base\n").hexdigest()}
+        report = sync_back(exp, ws, ["src"], baseline=baseline,
+                           merge_on_conflict=["*.log"])
+        assert report.conflicts == ()
+        assert report.merged_paths == ("src/build.log",)
+
+    def test_export_deleted_merge_path_is_hard_conflict(self, tmp_path):
+        ws = _workspace(tmp_path)
+        exp = _export(tmp_path, ws)
+        (ws / "src" / "audit.md").write_text("host\n")
+        baseline = {"src/audit.md": hashlib.sha256(b"base\n").hexdigest()}
+        report = sync_back(exp, ws, ["src"], baseline=baseline,
+                           merge_on_conflict=["src/audit.md"])
+        assert report.conflicts == ("src/audit.md",)
+        assert report.merged_paths == ()
+        assert report.synced_paths == ()
+        assert (ws / "src" / "audit.md").read_text() == "host\n"
+
+    def test_host_deleted_merge_path_is_hard_conflict(self, tmp_path):
+        ws = _workspace(tmp_path)
+        exp = _export(tmp_path, ws)
+        (exp / "src" / "audit.md").write_text("export\n")
+        baseline = {"src/audit.md": hashlib.sha256(b"base\n").hexdigest()}
+        report = sync_back(exp, ws, ["src"], baseline=baseline,
+                           merge_on_conflict=["src/audit.md"])
+        assert report.conflicts == ("src/audit.md",)
+        assert report.merged_paths == ()
+        assert report.synced_paths == ()
+        assert not (ws / "src" / "audit.md").exists()
+
+    def test_export_only_change_on_merge_path_still_copies(self, tmp_path):
+        ws = _workspace(tmp_path)
+        exp = _export(tmp_path, ws)
+        (ws / "src" / "audit.md").write_text("base\n")
+        (exp / "src" / "audit.md").write_text("base\nexport\n")
+        baseline = {"src/audit.md": hashlib.sha256(b"base\n").hexdigest()}
+        report = sync_back(exp, ws, ["src"], baseline=baseline,
+                           merge_on_conflict=["src/audit.md"])
+        assert report.conflicts == ()
+        assert report.merged_paths == ()
+        assert "src/audit.md" in report.synced_paths
+        assert (ws / "src" / "audit.md").read_text() == "base\nexport\n"