| name | bundle-ship |
| description | Bundles all uncommitted work from multiple Cursor agent threads on the same branch and checkout into one finish commit, then pushes. Use when the user runs /bundle-ship, /finish-all, or asks to finish and push everything across threads on one checkout. |
bundle-ship
Land all uncommitted changes on the current branch and checkout when multiple agent threads may have contributed — one bundled commit, then push.
SSOT for commit mechanics: .agents/skills/finish/SKILL.md (bundle mode).
SSOT for push mechanics: .agents/skills/push/SKILL.md.
When to use
Use bundle-ship | Use plain finish → push instead |
|---|
| Multiple agent chats touched the same working folder | Single thread owns the full diff |
| User wants one commit for the whole tree snapshot | User wants thread-scoped commit only |
User explicitly invokes /bundle-ship or /finish-all | Normal session wrap-up |
Skip gate: Clean tree with nothing to commit → report and stop (do not invent work).
What this skill owns
Orchestration and bundle intent only. It does not duplicate version rules, staging gates, changelog format, or push safety checks — those stay in finish and push.
Preconditions
- Same branch, same checkout — not worktrees, not per-thread branches.
- Other threads idle — user has paused or finished other agent chats on this checkout. This skill cannot stop other agents.
- User invoked bundle-ship (explicit combined finish + push intent).
If git status or the full diff changes between two fresh reads without this thread editing those paths, stop. Tell the user the tree is still moving; wait until other threads are idle, then re-run.
Workflow
Copy and track:
Bundle-ship progress:
- [ ] Step 1: Snapshot the full tree
- [ ] Step 2: Confirm bundle scope with user
- [ ] Step 3: Run finish (bundle mode)
- [ ] Step 4: Run push
Step 1: Snapshot the full tree
- Run
git status -sb and read the full diff from disk (git diff and git diff --cached; include untracked paths that belong in the release).
- Summarize everything that would land — by area/feature, not by which thread wrote it.
- Do not filter to “this thread’s files.” The perimeter is the entire working tree.
Step 2: Confirm bundle scope
Tell the user:
- What files and areas are included.
- That version/changelog (if required) will describe the full bundle, per
finish semver rules.
- That other agent threads on this checkout should be paused.
Ask once: ready to bundle-finish and push this snapshot?
If the user declines, stop. If they want thread-scoped finish instead, route to plain finish (no push in that turn unless they ask).
Task backlog: If src/config/app-tasks.json has multiple in-progress rows from different threads, ask which task(s) to archive before commit — same as finish, but expect ambiguity more often in multi-thread landings.
Step 3: Run finish (bundle mode)
Read .agents/skills/finish/SKILL.md and execute it with these overrides:
finish default | bundle-ship override |
|---|
| Concurrent smoke → AskQuestion (pause / bundle / stash / wait) | Skip the four-option menu — user already chose bundle by invoking this skill |
| Scope = this thread’s work | Scope = full tree from Step 1 |
| Ends with offer to push | Continue to Step 4 in this same turn after a successful commit |
| Stash lane / wait-and-recheck | Out of scope — user must pause other threads first |
Follow all other finish requirements: archive task when applicable, version/changelog gate, staging decision gate, ready-to-commit confirmation, commit message standards, protected files, feature-doc validation.
One commit for the full snapshot. Changelog and version bump (when required) must reflect all bundled changes.
Step 4: Run push
After a successful commit:
- Read
.agents/skills/push/SKILL.md and execute it in this same turn.
- User already asked for ship — push confirmation may be a single “ready to push this bundled commit?” (still required; do not push without confirmation).
- If push preconditions fail (dirty tree, behind remote), stop per
push and report — do not commit-fix inside push.
Non-goals
| Will NOT do | Mark |
|---|
| Per-thread separate commits | excluded |
| Coordinate git worktrees or merge branches first | excluded |
| Stash other threads’ work and restore after push | excluded — use plain finish Option 3 if needed |
| Auto-poll or wait for other threads | excluded — user pauses them |
Replace finish or push rules | excluded — delegates SSOT |
| Open PRs or promote to production | deferred — after push, user opens PR per workflow rules |
Boundaries
Not bundle-ship | Use instead |
|---|
| Single-thread wrap-up | finish → push |
| Only push existing commits | push |
| Validate before landing | validate |
| Concurrent smoke; user unsure about bundle | finish (full AskQuestion menu) |
Invocation aliases
Treat these as the same skill: /bundle-ship, /finish-all, “finish and push everything across threads.”
