Better handle modify/delete conflicts. (#19)

## Description

When a cherry-pick encounters a modify/delete conflict (one side
modifies a file the other deleted), git does not produce conflict
markers. The existing `git add -A` step silently resolves these by
keeping the file, and the conflict-resolution agent has no signal that a
conflict occurred — so it does nothing.

This change detects modify/delete conflicts from `git status
--porcelain` before staging, writes a `.repo-sync-conflicts.json`
manifest to the working tree (not committed), and updates the
conflict-resolution skill to consume it. The agent now knows about these
conflicts and defaults to honoring the deletion.

## Testing

Manual — will be exercised by the next cherry-pick conflict that
involves a deleted file.

Author: vorporeal

.agents/skills/conflict-resolution/SKILL.md

@@ -9,11 +9,11 @@ you are a merge conflict resolution agent.  your job is to resolve git merge con
 
 ## context
 
-you are checked out on a branch that has conflict markers in its code.  this can happen in two ways:
-1. **in-progress git operation** (rebase, cherry-pick, or merge): the conflicting files are unresolved in the git index.
-2. **committed conflict markers**: the conflict markers were committed as-is (e.g., by the sync workflow to preserve the raw conflict for review).  there is no in-progress git operation.
+you are checked out on a branch that has conflicts.  these can take two forms:
+- **text conflicts**: conflict markers (`<<<<<<<` / `=======` / `>>>>>>>`) in file contents.  these appear either as unresolved index entries (in-progress git operation) or as committed markers (case 2: the sync workflow committed them as-is for review).
+- **modify/delete conflicts**: one side modified a file while the other deleted it.  these do **not** produce conflict markers.  instead, the sync workflow detects them before staging, records them in a manifest file (`.repo-sync-conflicts.json` in the repo root), and commits the file as-is (kept).  the manifest is written to the working tree (not committed) for you to consume.
 
-your job is to resolve the conflict markers and commit the result.  the calling workflow handles pushing -- **do not push**.
+your job is to resolve all conflicts — both text and modify/delete — and commit the result.  the calling workflow handles pushing -- **do not push**.
 
 ## environment
 
@@ -37,7 +37,40 @@ grep -rln --exclude-dir=.git '^<{7}\s' .
 
 this gives you the list of files containing conflict markers.
 
-### 2. read and understand each conflict
+### 2. check for modify/delete conflicts
+
+check whether the calling workflow left a modify/delete manifest:
+```sh
+cat .repo-sync-conflicts.json 2>/dev/null
+```
+
+if the file exists, it contains a JSON object like:
+```json
+{
+  "context": "Cherry-pick conflict. 'ours' = current branch (target), 'theirs' = cherry-picked commit (source).",
+  "modify_delete_conflicts": [
+    { "path": "src/foo.rs", "deleted_by": "ours" },
+    { "path": "src/bar.rs", "deleted_by": "theirs" }
+  ]
+}
+```
+
+the `context` field explains what `ours` and `theirs` mean for this conflict.  `deleted_by` tells you which side deleted the file; the other side modified it.  because `git add -A` was run before the commit, the file currently **exists** in the committed tree (the deletion was not honored).
+
+for each modify/delete conflict:
+- read the file to understand the modifications.
+- look at git log and surrounding context to understand why the other side deleted it.
+- **default heuristic**: honor the deletion (`git rm <file>`).  the side that deleted the file made an intentional decision, and the modifications from the other side are typically moot.  for example, if the target branch deleted a file and the cherry-picked commit only tweaks a few lines in it, the correct resolution is almost certainly to delete the file.
+- **exception**: keep the file if the modification is clearly important and independent of the deletion (e.g., the deletion was part of a rename and the modification adds critical new content that should follow the rename).  if you keep the file, no action is needed — it is already in the committed tree.
+
+after processing all modify/delete conflicts, **delete the manifest**:
+```sh
+rm -f .repo-sync-conflicts.json
+```
+
+if the manifest does not exist, skip this step — there are no modify/delete conflicts.
+
+### 3. read and understand each text conflict
 
 for each conflicting file:
 - read the entire file.
@@ -53,7 +86,7 @@ for each conflicting file:
   the `<ref-or-label>` after `<<<<<<<` and `>>>>>>>` tells you which branch or commit each side came from.  **read these labels carefully** -- the meaning of "first side" vs. "second side" depends on whether the conflict arose from a `git merge` or a `git rebase` (rebase swaps the sides relative to merge).  do not assume which side is "ours" or "theirs" -- always check the labels.
 - look at surrounding code and other files in the repository for context on what the correct resolution should be.
 
-### 3. resolve each conflict
+### 4. resolve each text conflict
 
 edit each conflicting file to remove all conflict markers and produce the correct merged result.  every conflict region must be resolved -- there must be zero `<<<<<<<`, `=======`, or `>>>>>>>` markers remaining in any file.
 
@@ -62,7 +95,7 @@ after editing, stage each resolved file:
 git add <file>
 ```
 
-### 4. verify: no remaining conflict markers
+### 5. verify: no remaining conflict markers
 
 run a search across the entire repository to confirm no conflict markers remain:
 ```sh
@@ -71,9 +104,9 @@ grep -Ern --exclude-dir=.git '^<{7}([^<]|$)|^={7}([^=]|$)|^>{7}([^>]|$)' .
 
 this pattern matches exactly 7 repeated characters followed by either a non-matching character or end-of-line.  the end-of-line alternative is needed because conflict markers (especially `=======`) can appear as bare lines with nothing after them.
 
-if any markers remain, go back to step 3 and resolve them.
+if any markers remain, go back to step 4 and resolve them.
 
-### 5. finalize the resolution
+### 6. finalize the resolution
 
 the correct command to finalize the resolution depends on which git operation caused the conflict.  detect the in-progress operation and use the appropriate command:
 

src/repo_sync/stack/git_ops.py

@@ -164,6 +164,31 @@ def conflicting_files(self) -> list[str]:
             return result.stdout.strip().splitlines()
         return []
 
+    def get_modify_delete_conflicts(self) -> list[dict[str, str]]:
+        """Return modify/delete conflicts detected from the unmerged index.
+
+        Must be called while the cherry-pick (or merge/rebase) is still
+        in-progress — i.e., before ``git add -A`` resolves the index.
+
+        Each returned dict has:
+          - ``path``: the conflicting file path.
+          - ``deleted_by``: ``"ours"`` if our side deleted the file
+            (porcelain ``DU``), or ``"theirs"`` if their side deleted it
+            (porcelain ``UD``).
+        """
+        result = self._run(["status", "--porcelain"], check=False)
+        conflicts: list[dict[str, str]] = []
+        for line in result.stdout.splitlines():
+            if len(line) < 4:
+                continue
+            xy = line[:2]
+            path = line[3:]
+            if xy == "DU":
+                conflicts.append({"path": path, "deleted_by": "ours"})
+            elif xy == "UD":
+                conflicts.append({"path": path, "deleted_by": "theirs"})
+        return conflicts
+
     def archive_to_dir(self, ref: str, target_dir: str) -> None:
         """Extract the tree at a ref into a directory via git archive.
 

src/repo_sync/workflows/create_sync_prs.py

@@ -412,20 +412,55 @@ def _handle_cherry_pick_conflict(
     optionally invokes the conflict-resolution agent to add a resolution
     commit on top, then creates the PR with appropriate trailers and labels.
     """
-    # Step 1: Commit the raw conflict as-is.
+    # Step 1: Detect modify/delete conflicts before staging resolves them.
+    # In a cherry-pick, "ours" = current branch (target), "theirs" =
+    # cherry-picked commit (source).  git add -A will silently keep the
+    # file in both cases, which may not be the correct resolution.
+    md_conflicts = peer_git.get_modify_delete_conflicts()
+    if md_conflicts:
+        logger.info(
+            "Detected %d modify/delete conflict(s): %s",
+            len(md_conflicts),
+            [c["path"] for c in md_conflicts],
+        )
+
+    # Step 2: Commit the raw conflict as-is.
     origin_trailer = f"Repo-Sync-Origin: {source_repo}@{source_sha}"
     peer_git.add_all()
     peer_git.commit(commit_message, trailers=[origin_trailer])
 
-    # Step 2: Invoke the conflict-resolution agent to produce a separate
+    # Step 3: If there were modify/delete conflicts, write a manifest to
+    # the working tree so the conflict-resolution agent can act on them.
+    # The manifest is intentionally NOT committed — it is a transient
+    # signal consumed and deleted by the agent.
+    manifest_path = os.path.join(peer_git.repo_dir, ".repo-sync-conflicts.json")
+    if md_conflicts:
+        manifest = {
+            "context": (
+                "Cherry-pick conflict. "
+                "'ours' = current branch (target), "
+                "'theirs' = cherry-picked commit (source)."
+            ),
+            "modify_delete_conflicts": md_conflicts,
+        }
+        with open(manifest_path, "w") as f:
+            json.dump(manifest, f, indent=2)
+            f.write("\n")
+
+    # Step 4: Invoke the conflict-resolution agent to produce a separate
     # resolution commit on top.  The agent runs in Docker and sees the
-    # committed conflict markers (case 2 in the skill).
+    # committed conflict markers (case 2 in the skill) plus the manifest
+    # for any modify/delete conflicts.
     from repo_sync.workflows.agent import run_conflict_resolution_agent
 
     agent_succeeded = run_conflict_resolution_agent(
         repo_dir=peer_git.repo_dir,
         context=f"Cherry-pick conflict on branch {sync_branch}.",
     )
+
+    # Clean up the manifest if the agent left it behind.
+    if os.path.exists(manifest_path):
+        os.remove(manifest_path)
     if agent_succeeded:
         logger.info("Agent produced a resolution commit for %s.", short_sha)
     else:
@@ -434,7 +469,7 @@ def _handle_cherry_pick_conflict(
             "PR will contain raw conflict markers.", short_sha,
         )
 
-    # Step 3: Push and create the PR.
+    # Step 5: Push and create the PR.
     conflict_trailer = format_conflict_trailer()
     pr_body = append_trailer(pr_body, origin_trailer)
     pr_body = append_trailer(pr_body, conflict_trailer)
@@ -452,7 +487,7 @@ def _handle_cherry_pick_conflict(
         )
         return
 
-    # Step 4: Add conflict label.
+    # Step 6: Add conflict label.
     peer_gh._run(
         ["label", "create", "repo-sync:conflict",
          "--color", "D93F0B",
@@ -465,7 +500,7 @@ def _handle_cherry_pick_conflict(
          "--add-label", "repo-sync:conflict"],
     )
 
-    # Step 5: Determine and assign reviewer.
+    # Step 7: Determine and assign reviewer.
     source_gh = GhOps(source_repo, token=os.environ.get("GH_TOKEN"))
     reviewer = determine_sync_reviewer(
         source_gh=source_gh,
@@ -478,7 +513,7 @@ def _handle_cherry_pick_conflict(
         check=False,
     )
 
-    # Step 6: Add Repo-Sync-Assigned trailer to PR body.
+    # Step 8: Add Repo-Sync-Assigned trailer to PR body.
     assigned_trailer = format_assigned_trailer(reviewer, datetime.now(timezone.utc))
     current_body = peer_gh._run(
         ["pr", "view", str(pr_number), "--repo", peer_gh.repo,
@@ -493,7 +528,7 @@ def _handle_cherry_pick_conflict(
         pr_number, short_sha, reviewer,
     )
 
-    # Step 7: Slack notification.
+    # Step 9: Slack notification.
     msg = (
         f"repo-sync: cherry-pick conflict for {source_sha[:7]} in "
         f"{peer_gh.repo}. Conflict PR #{pr_number} created."