Merge from the git tree

Folding one branch into another - a finished run’s branch into main, or two pieces of work together - is something the Git tree lets you see before you do it. It is the Source page’s Tree tab in Mission Control, and the interactive canvas has no CLI equivalent by design.

The per-run path does have one:

vibe integrate advise <runId>    # read-only: what would merging this do?
vibe integrate apply <runId> --into integration/logging
vibe integrate finish integration/logging \
  --confirm merge-to-main

The left panel is the commit graph: a lane rail beside commit rows carrying the subject, the diff size (+added -removed), the author and the short hash. Branch tips render as labelled ring nodes so a tip never looks like a plain commit, and main is the violet spine. On a large repository the graph is bounded to the most recent commits.

Click a commit and its history stays lit while everything unrelated dims; if the commit reached main through a merge, the merge commit is marked merged here.

Switch the left panel from Graph to Branches for a flat list of every local branch - the view that still works when history is linear and the graph collapses to one rail. Each row shows the branch’s standing against main: how far ahead and behind (up/down), its diff size, merged or open, and its latest commit. A ledger up top counts open against merged. Click a branch to focus its tip in the graph and stage it as the merge planner’s source.

The Inspector in the middle answers the first question about any commit - is it on main? - as a toned status (on main / merged / unmerged), then the diff totals, the files it changed with per-file +/-, the full message body, and its parents and branch tips as jump links, each marked merged or open.

In the Merge planner on the right, pick a source and a target branch. The pickers annotate every branch as main, merged or open, and if the pair is already merged the planner says so before any prediction runs. Then Predict: Vibestrate performs the merge in a throwaway worktree - never on a real branch - and tells you one of three things:

The prediction is read-only and the scratch worktree is always torn down. When every branch is already merged, the planner says so instead of offering a no-op.

Ask the supervisor sits above the planner’s actions, with an Ask button that consults your local provider: which open branch is worth merging next, and whether the pair you picked is safe to merge now. It answers with a confidence level and its caveats, and it never merges for you.

Guided merge goes further: it runs the prediction and, on a conflict, has the supervisor propose a resolution. Applying the result is still a separate, explicit click.

On a conflict, Ask supervisor to propose has your local provider - the same assist path the rest of Vibestrate uses - propose a merged version of each conflict region with a rationale. You review a three-way view (ours / theirs / proposed) and edit the result before anything is written. The proposal is the whole file with the conflict regions resolved, so the lines that did not conflict are preserved. Apply resolved merge is what writes it.

This step is secret-safe by construction:

• A file whose path looks secret-like (a .env, a key file) is refused outright and never sent to a provider - resolve it yourself.
• Conflict bodies are redacted of secret-shaped tokens before they reach the provider.
• A binary or unparseable conflict is flagged for manual resolution.

The supervisor never commits.

Apply merge performs the real merge on the target branch with --no-ff, so it is always a merge commit, after recording the target’s pre-merge sha. It is gated through the Action Broker (git.merge), refuses a dirty tree or a target that is not checked out, and never moves your HEAD or pushes.

Undo merge resets the branch back to the recorded pre-merge sha. It is guarded: it refuses once anything has been built on top of the merge, once the merge has reached an upstream (best-effort push detection), if the recorded point has drifted, or if uncommitted work would be discarded. It can only reverse a merge that is still safe to reverse.

The Merge tab beside Tree is the run-shaped version of the same job, and what vibe integrate drives:

vibe integrate advise            # every merge-ready run
vibe integrate advise <runId> --json
vibe integrate preview           # dry-run conflict report
vibe integrate apply <runId> --into integration/<name>
vibe integrate finish integration/<name> \
  --confirm merge-to-main

advise is computed from git facts and check lanes - no model output - and merges nothing. apply integrates into a dedicated branch, never main. finish is the only one that reaches main: it takes the integration branch as its argument and the exact token merge-to-main, either as --confirm or typed at the prompt. Any other value exits 2 rather than falling through to the prompt, it refuses partial integrations, dirty trees and conflicts, and it is local only - nothing is pushed.

Merges only - no rebase, squash, cherry-pick, amend or force. No auto-merge, no auto-apply, no push. The interactive canvas is UI-only by design; the underlying operations are plain git, so the merge advisor and vibe integrate remain the terminal path for the per-run flow.