# Merge Desk

> Paste a file still carrying git conflict markers and work the stuck merge in one sitting: triage
> every hunk, merge the ones that need judgement, or review a proposed resolution before it is pushed.
> https://merge-desk.skillsafe.ai/

Merge Desk is a browser app on the SkillSafe platform. It is a derived work built on two published
agent skills: `@mattpocock/resolving-merge-conflicts` (the primary) and `@obra/requesting-code-review`.
It is not affiliated with those skills' authors, nor with Git, GitHub or the Git project.

## What it is for

One work object: the text `git` left behind when a `merge`, `rebase` or `cherry-pick` stopped. Three
lanes over that same text, in the order a person meets them.

| Lane id | Name | Question it answers |
| --- | --- | --- |
| `triage` | Triage every hunk | What was each side trying to do, and how should each hunk be settled? |
| `resolve` | Merge the hunks | What is the merged text, and what did not survive? |
| `review` | Review the resolution | Did this merge lose anything, and is the result coherent? |

The handoff is a button: `triage` leads to `resolve`, and `resolve` hands its rewritten file straight
into `review` as the resolution to check.

## What is free, with no account

The whole deterministic half runs in the browser and is never charged:

- **A real conflict parser.** A state machine over the marker lines. It handles two-way markers and
  `diff3` markers (with the merge base), several files in one paste (`# file: path`, `diff --git`,
  `+++ b/path`, or dropped files), markers nested inside a hunk from an earlier bad merge, and a
  stray `=======` left by hand-editing a file mid-merge. Malformed cases are reported, not
  mis-read.
- **Per-hunk measurement.** Line counts per side, which side is empty, whether a side is
  byte-identical to the merge base, whether the sides differ only in whitespace, indentation-unit
  and line-ending mismatches, control bytes, and a dependency-version-only difference.
- **A classification per hunk**: `whitespace-only`, `import-block`, `one-side-empty`,
  `version-bump`, `overlapping-edit`, `lockfile`, `generated`, `migration-order`, `test-file`,
  `one-side-unchanged`, `superset`, `binary`, `empty`, `truncated`.
- **A mechanical resolver.** Take ours, take theirs, take both, or *only what is provable*. It
  rewrites the paste with the chosen sides substituted and the markers gone. A hunk with no decision
  keeps its markers and is named, so the output is never silently half-merged. Lockfiles are excluded
  from take-ours and take-theirs by design.
- **Dropped-line detection.** Given a proposed resolution: which substantive lines from each side are
  absent, with lines that were also in the merge base excluded because those were never that side's
  change. Plus an untouched-context check that catches a resolution which reformatted code outside
  the conflicts, a bracket census, and a `JSON.parse` check when the file is JSON.
- **Regeneration commands** for twenty lockfile formats, because a lockfile is generated output and a
  hand-merged one parses and lies.
- Every export of the above: copy, download the resolved file, a unified diff against the conflicted
  paste, Markdown, JSON, CSV.

## The one thing worth knowing before you paste

With `diff3` markers the merge base is in the file. If your side is byte-identical to the base then
your side changed nothing there, so taking the other side **provably** loses nothing. That is a fact,
not a judgement, and Merge Desk applies exactly those hunks for free. Run:

```
git checkout --conflict=diff3 <path>
```

before you paste, and more of the conflict becomes provable rather than arguable.

## What the model lanes add

Metered, signed-in, `gpt-terra` at a 10% publisher markup. What the parser cannot do is read intent,
and intent is the whole problem with a merge conflict.

- `triage` recovers **both sides' intent** per hunk and recommends `take-ours`, `take-theirs`,
  `take-both`, `hand-merge`, `regenerate` or `ask-author`, with confidence and risk, plus the order to
  work them in and honest advice when aborting and redoing the merge is cheaper than finishing it.
- `resolve` produces the merged text per hunk and the whole file, and is required to name every line
  that did **not** survive, on each side, with a reason. A hunk it will not merge is returned
  explicitly unresolved rather than guessed at.
- `review` runs nine named checks, tabulates dropped changes with severity, lists semantic risks with
  a way to disprove each, names the tests the merge requires, and writes a pull-request comment.

Every prescan flag is sent with the run and the model must return one `coverage_check` entry per flag.
A flag it does not account for is displayed as unaccounted for. The model is told it never ran
anything, and it is instructed never to invent a file, a symbol or a merge base it was not given.

## Contract

Input, as `app.js` submits it:

```json
{
  "task": "triage",
  "conflicted": "<the file with its markers>",
  "resolution": "<review lane only: the proposed merged text>",
  "strategy_hint": "prefer-neither",
  "branch_context": "what ours is, what theirs is",
  "prescan": { "style": "diff3", "counts": {}, "files": [], "hunks": [], "flags": [] },
  "resolution_check": { "markers_left": 0, "dropped_from_ours": [], "dropped_from_theirs": [] }
}
```

Output: one JSON object, the same envelope for every lane — `lane`, `lane_inferred`, `title`,
`posture` (`safe-to-resolve` / `needs-author` / `blocked`), `verdict`, `summary`, `file_count`,
`hunk_count`, `assumptions`, `open_questions`, `findings[]`, `coverage_check[]`, `artifact`,
`next_lane`, and a per-lane `body`. Full field lists and one worked example per lane are in
[/api.html](https://merge-desk.skillsafe.ai/api.html).

## Limits, stated plainly

- Merge Desk never runs `git`, never reads a repository, never writes to your disk and never executes
  your code. Commands it shows are for you to read and run.
- It cannot tell you whether merged code is *correct*. It can tell you what text has gone missing and
  what a careful colleague would want re-tested.
- Without `diff3` markers the merge base is unknown, and whether a side changed anything is not
  derivable. The app says so rather than guessing.
- A lockfile is never merged. It is detected and you are given the regeneration command.
- Binary content cannot be merged as text; the app says which side to take wholesale.

## Pages

- [/](https://merge-desk.skillsafe.ai/) — the app.
- [/api.html](https://merge-desk.skillsafe.ai/api.html) — driving it programmatically, in eight
  languages, with a worked example per lane.
- [/tokens.html](https://merge-desk.skillsafe.ai/tokens.html) — the token panel. Not indexed.