git:20261019.0d0f945 to git:20261019.e93ae54

+ description: 'Absorb one or more feature branches into the base branch. One branch: recommends merge vs rebase. Two or more (or `--batch` for any number): batch landing through one integration branch off base — a conflict on derived output only settles by the repo''s declared regenerate command, one verify on the integrated tree (red → a linear scan names the first red merge), base fast-forwards once. On any other conflict, aborts that branch + surfaces the file list. Resolution out of scope; routes to the harness-named conflict-resolution agent (stages the resolution and reports; the gateway concludes it) or the user.'

+ Absorb feature branches into the base branch; several branches land as one batch (§ 5b). **Conflict resolution is NOT this skill's job** — abort, surface, stop. Regenerating derived output (§ 5b step 2) is not resolution: it takes no judgment.

+ The gateway reads the staged resolution and concludes it in the main session with `git -c core.editor=true merge --continue` or `git -c core.editor=true rebase --continue` (non-interactive in any shell; a pathspec commit is refused mid-merge). A rebase that stops again on a later commit goes back out as a new resolver scope on the same branch, not through the Conflict Doctrine's abort.

+ - `--batch`: land through § 5b even for one branch

+ A shared or occupied branch takes Merge --no-ff whatever its commit count. In a batch landing (§ 5b) every branch takes Merge --no-ff — its per-branch merge commit is a point the red scan checks.

+ Present recommendations as a table; name the holding worktree's path beside an occupied branch. Wait for user confirmation before executing. Two or more confirmed branches, or `--batch` with any number → § 5b; one → § 5.

+ ### 5. Execute sequentially (one branch)

+ ### 5b. Batch landing (two or more branches, or `--batch`)

+

+ The branches merge in confirmed order into one integration branch off `{base}`; the verify runs once on the integrated tree; `{base}` moves once, by fast-forward. Run every git command in the current worktree (cwd); never run git inside another worktree.

+

+ **Derived output** — a path the repo's docs (`docs/techstack.md` or CLAUDE.md Commands) name, beside a regenerate command, as a path that command writes. A regenerate command declared without the paths it writes settles no conflict: the conflict takes the Conflict Doctrine, and § 7 reports the missing declaration.

+

+ 1. **Open the integration branch** — record `{base}`'s tip as `{base-tip}`, then `git checkout -b integrate/{base}-{YYYYMMDD-HHMMSS} {base}`.

+ 2. **Merge each branch, in confirmed order** — `git merge {branch} --no-ff -m "merge: {branch}"`. On a stop with unmerged paths (`git diff --name-only --diff-filter=U`):

+ - **Every unmerged path is derived output** → settle by regeneration: `git checkout --theirs -- <paths>` (either side serves — the command overwrites it), run the regenerate command(s) declared for those paths, `git add <paths>`, confirm the unmerged-path list is empty, then conclude with `git -c core.editor=true merge --continue`. Then `git status --porcelain` must be empty: declared derived paths the command wrote beyond the unmerged list → `git add -- <declared paths>` + `git commit --amend --no-edit`; any other path → surface it and stop the batch, `{base}` untouched. Record the branch as settled by regeneration, with the command run. A regenerate command that exits non-zero → handle the stop as the next bullet, with the command's error in the surface.

+ - **Any unmerged path is not derived output** (a modify/delete conflict on a derived path counts as not derived) → the Conflict Doctrine: abort this branch's merge, surface it with the integration branch as its merge target, continue with the next branch.

+ - A failed command with no unmerged paths → § 5's not-a-conflict line.

+

+ The step ends when every confirmed branch is merged into the integration branch, surfaced, or skipped.

+ 3. **Settle surfaced branches** — per surfaced branch, offer: dispatch the conflict-resolution agent (§ Resolver contract, merge target = the integration branch; the gateway concludes it there) or leave the branch out of this batch. The step ends when every surfaced branch is concluded on the integration branch or left out.

+ 4. **Verify once, on the integrated tree** — provisioning first, as the repo's docs declare it: the install command when `git diff --name-only {base-tip}..HEAD` names a manifest or lockfile, then every regenerate command. Then the declared verify command (the `## Staged-Tree Verify` block in `docs/techstack.md`): exit 0 = green, non-zero = red. No verify command declared → skip provisioning (step 2 already settled the derived conflicts) and go to step 6; § 7 reports the verify as none declared. Green → step 6. Red → step 5.

+ 5. **Red → find the first red merge** — a linear scan in landing order over `{base-tip}`, then each merge in `git rev-list --first-parent --reverse {base-tip}..integrate/…`. The detached checkouts here are this step's own (§ Rules' detached-HEAD stop applies at the run's start). Per commit, as separate calls:

+ 1. `git checkout -- .`, then `git clean -fd -- <declared derived paths>`.

+ 2. `git checkout <sha>`.

+ 3. Provisioning (step 4). Non-zero → surface it as a provisioning failure with its output, name no culprit, stop the scan.

+ 4. The declared verify. Non-zero → this commit is the first red: at `{base-tip}`, `{base}` itself is red; at a merge, report "first red at the merge of {branch}" (from its `merge: {branch}` subject, else the confirmed list by position — it may be an interaction with earlier branches), with the verify output; stop the scan. Every commit green → surface the red as not reproduced.

+

+ Then `git checkout -- .`, `git clean -fd -- <declared derived paths>`, `git checkout integrate/…`. The step ends with HEAD on the integration branch, `git status --porcelain` empty, `{base}` at `{base-tip}`; the integration branch stays for inspection, no fast-forward.

+ 6. **Green → fast-forward once** — `git status --porcelain -- <declared derived paths>` non-empty → `git add -- <declared derived paths>`, `git commit -m "chore: regenerate derived output"`. Any other dirty path → surface it; no commit, no fast-forward. Then `git checkout {base}`, `git merge --ff-only integrate/…`, `git branch -d integrate/…`. A refused fast-forward (`{base}` moved during the batch) → surface git's error line and keep the integration branch.

+

+ - Batch landing: the integration branch, branches settled by regeneration (with the command run), any conflict that took the Conflict Doctrine because its regenerate command declares no written paths, the verify result (green; red with the first red merge, or a provisioning failure; or none declared), and whether `{base}` fast-forwarded

+ Probe first, ask second — the probe is a fact the gateway reads itself. `git remote` prints nothing → no push surface: §7's report is the next and only output. A remote but no upstream for the base (`git rev-parse --abbrev-ref @{u}` errors) → say so in one line and ask once: **"Set upstream and push {base} (`git push -u <remote> {base}`)? (y / skip)"** — `<remote>` is the sole remote, or the one the user names when several exist. Remote + upstream → present base → remote, commits ahead of remote, which branches were folded in; ask **"Push {base} now? (y / skip)"**. Push on explicit yes only; skip on silence or decline. Never force. Branches that hit conflicts are not pushed. `{base}` did not move (a batch landing that stopped red or before its fast-forward) → no push ask. Same push-probe shape as the commit skill's § 6.

+ - Never resolve conflicts inline. Surface and stop. (See Conflict Doctrine above.) A conflict on derived output only settles by its declared regenerate command (§ 5b step 2).

+ - Never delete the absorbed branches. The batch's own integration branch goes with `git branch -d` once `{base}` holds it.