Seal

---
name: seal
description: Ships a feature — simplify pass, certify, commit, PR, CI monitoring, review loop, merge. Use when a feature branch is verified and ready to ship.
allowed-tools: Read, Task, AskUserQuestion, Edit(./CLAUDE.md), Edit(./README.md), Bash(git add -A), Bash(git commit -m *), Bash(git push -u origin HEAD), Bash(gh pr create *), Bash(gh pr checks *), Bash(gh pr view *), Bash(gh pr merge --squash --delete-branch), Bash(gh run view *)
argument-hint: "[pr-title]"
---

# /seal — Ship to Production

Take a certified feature branch through to a merged PR. This skill performs irreversible actions (push, PR, merge) — it presents a single consolidated ship-summary and waits before the first outward command (`git push`).

## Pre-flight

- Confirm /certify has been run and passed
- Confirm the /scrutinize review + remediation cycle is complete (or explicitly skipped by user)
- **Never ship on stale evidence** — /certify must have passed in *this* session (fresh output you read this turn), not a remembered run. See [lore/verification.md](../../lore/verification.md).

## Autonomy — approve the plan, then run

Once Pre-flight is confirmed (/certify passed, /scrutinize + remediation complete or explicitly skipped), the ship sequence runs **autonomously**: the Simplifier Pass, Final Certify, Update Documentation, and Commit steps proceed without stopping to ask the owner. Claude Code's built-in read-only commands (including read-only git) don't prompt; this skill pre-approves the exact commit, push, PR, CI-check and merge commands shown below and edits to `CLAUDE.md`/`README.md`; any other edit or command goes through the normal permission prompt unless the user runs in auto mode. Re-gate **only** on outward side effects — `git push`, `gh pr create`, `gh pr merge` — surfaced once through the consolidated ship-summary gate below, not per command. Doctrine: [lore/autonomy.md](../../lore/autonomy.md).

## Process

### 1. Simplifier Pass
Dispatch the simplifier via `Task` with subagent type `magician:simplifier` for a final simplification sweep. Give it a self-contained prompt: the goal, the changed files (with diff), and the return format (see [lore/subagent-context.md](../../lore/subagent-context.md)). Fix any Important findings. Skip Low suggestions unless trivial.

### 2. Final Certify
Run /certify. All checks must pass before continuing — including style vs the project's documented conventions ([lore/code-standards.md](../../lore/code-standards.md)), so review bounces on style don't reopen the ship loop.

### 3. Update Documentation
Before committing, update docs to reflect the shipped feature:
- **CLAUDE.md** — add or update any changed commands, env vars, architecture notes, or setup steps
- **README.md** — update feature list, screenshots, or usage examples if the change is user-visible
- Any other docs that reference the changed code (API docs, architecture diagrams, etc.)

Keep updates minimal and accurate — document what changed, not the implementation details.

### 4. Commit
```bash
git add -A
git commit -m "feat: <feature description>

<bullet list of what was built>

Co-Authored-By: Claude <noreply@anthropic.com>"
```

### Ship-summary gate — one outward approval
Steps 1–4 ran autonomously. Before the first outward command (`git push`), present **one** consolidated ship-summary, then gate the outward push/PR/merge through **AskUserQuestion** — end your turn at the call and act on the choice. The summary covers:
- **Changed files** — the diff going out (from step 4's `git add -A`)
- **Commit message** — what was committed in step 4
- **PR title + body** — the title plus the Summary + Test plan from step 6
- **Merge strategy** — e.g. `--squash --delete-branch` (step 9)

Ask **"Ship this branch?"** with these options:
- **Ship it** — run Push, Create PR, and Merge without asking again
- **Revise** — adjust the commit, PR, or scope first; re-present the summary afterward
- **Cancel** — stop here; do not push, open a PR, or merge

Treat a free-form "yes / approved / looks good" as **Ship it**. On **Ship it**, run Push (step 5), Create PR (step 6), and Merge (step 9) without asking the owner again.

### 5. Push
```bash
git push -u origin HEAD
```

### 6. Create PR
Use the PR title + body approved at the ship-summary gate above — no separate title prompt:
```bash
gh pr create --title "<title>" --body "$(cat <<'EOF'
## Summary
- <what was built>
- <key decisions>

## Test plan
- [ ] All tests pass
- [ ] Types clean
- [ ] Lint clean
- [ ] Manually verified: <golden path>

Built with magician + Claude Code
EOF
)"
```
The `$(…)` body can keep this command from matching the `gh pr create` pre-approval; if Claude Code asks to confirm it, that is its own permission check, separate from the ship-summary gate.

### 7. Watch CI (evaluator-optimizer loop)
Run the checks watcher with the Bash tool's background option, so the turn isn't held open; you're notified when it exits, then read its output:
```bash
gh pr checks <pr> --watch
```

Then loop: **on a failing check → `gh run view <id> --log-failed` → fix → commit → `git push -u origin HEAD` → start the watcher again → repeat until every check is green.** For a long or unattended wait, pair with **`/goal`** ("PR checks green, then merged") so Claude keeps driving across turns; on a schedule, `/loop check CI on my PR` (self-paces when you omit the interval).

### 8. Review Comments
If reviewers add comments: use /scrutinize to process and remediate them, then /certify, then `git push -u origin HEAD`.

### 9. Merge (if auto-merge not enabled)
```bash
gh pr merge --squash --delete-branch
```

## disableGit Mode

If `disableGit: true`: skip push/PR/merge steps. Commit locally and report done.

## Obstacles

If this skill runs as a dispatched unit (under /orchestrate, /weave, /manifest, /transmute, or another skill) and hits something that blocks or degrades the work, do not wait for a human who is not there and do not silently ship a degraded result — return an Obstacles block to the caller, alongside whatever you did complete:

```
STATUS: BLOCKED | DEGRADED | NEEDS_CONTEXT
OBSTACLE: <one-line label of what blocked or degraded the task — the claim alone>
BLOCKER: <the specific, actionable cause — distilled, never a raw traceback or dumped log>
SEVERITY: Critical | High | Medium | Low
WORKAROUND: <what you did to proceed and what it leaves unverified; empty if still fully blocked>
RECURRENCE: First-seen | Recurring | Systemic
SCOPE: <this task only | likely hits sibling/downstream work too>
NEXT: <the action or decision the caller must make to clear it — retry with X, supply input Y, accept degraded, or escalate>
```

When invoked interactively by a human, surface the same obstacle in prose instead. Omit the block entirely on a clean run. See [lore/obstacles.md](../../lore/obstacles.md).

## Completion Signal

"Sealed. PR merged. Run /portal cleanup steps if applicable."