Agency ship

Great Minds Agency — Ship (GSD-Style)

Ship a verified project. Merges work, updates tracking, writes the completion report, and cleans up.

Context

This is the final phase in the pipeline: PRD -> Debate -> /agency-plan -> /agency-execute -> /agency-verify -> /agency-ship

Only run this after /agency-verify returns a SHIP recommendation. If verify returned FIX FIRST or BLOCK, resolve those issues first.

Instructions

Step 1: Pre-Ship Gate

Read and validate:

1. STATUS.md — confirm verification: SHIP
2. engineering/phase-{N}-verification.md — confirm no CRITICAL issues
3. Confirm all PRs from /agency-execute are merged or ready to merge

# Confirm we're on the right branch and tree is clean
git status --porcelain
git branch --show-current

# List feature branches that need merging
git branch --list "feature/*"

If verification status is not SHIP, STOP and tell the user to run /agency-verify first.

Step 2: Merge Feature Branches to Main

For each feature branch:

# Switch to main
git checkout main
git pull origin main

# Squash merge each feature branch
git merge --squash feature/{branch-name}
git commit -m "feat: {description of feature branch work}

Squash merge of feature/{branch-name}
Phase: {N}
Project: {project-name}

Co-Authored-By: Claude <[email protected]>"

Rules:

• Use squash merge to keep main history clean
• One commit per feature branch
• If merge conflicts occur, resolve them. If unresolvable, STOP and escalate to the user
• Run npm run build after each merge to confirm nothing breaks

Step 3: Update STATUS.md

Update STATUS.md to reflect shipped state:

state: shipped
phase: {N}
verification: SHIP
shipped_at: {ISO date}
shipped_by: Phil Jackson (orchestrator)
commit: {final merge commit SHA}

Include project-specific metrics:

• Total tasks completed
• Total commits merged
• Issues found and resolved during verify
• Time from plan to ship (if trackable)

Step 4: Update SCOREBOARD.md

Increment the relevant counters in SCOREBOARD.md:

• Total commits (add the new merge commits)
• PRs merged (add count of merged feature branches)
• Any new test specs added
• Any new source files added
• Update live deployment URLs if changed

Step 5: Write Ship Report

Write a completion summary to deliverables/{project}/ship-report.md:

# Ship Report: {Project Name}

**Shipped**: {date}
**Pipeline**: PRD -> Debate -> Plan -> Execute -> Verify -> Ship
**Duration**: {time from first debate to ship}

## What Was Built
{2-3 paragraph summary of what was delivered}

## Branches Merged
| Branch | Commits | Description |
|--------|---------|-------------|
| feature/... | N | ... |

## Verification Summary
- Build: PASS
- Tests: X/Y passing
- Requirements: X/Y verified
- Critical issues: 0
- Issues resolved during verify: {count}

## Key Decisions (from Debate)
{Top 3-5 decisions that shaped the project, pulled from rounds/{project}/decisions.md}

## Metrics
| Metric | Value |
|--------|-------|
| Tasks planned | {count} |
| Tasks completed | {count} |
| Tasks failed & retried | {count} |
| Commits | {count} |
| Files changed | {count} |
| Lines added | {count} |
| Lines removed | {count} |

## Team
| Agent | Role | Contribution |
|-------|------|-------------|
| Steve Jobs | Creative Director | {summary} |
| Elon Musk | Technical Director | {summary} |
| Margaret Hamilton | QA | {summary} |
| Phil Jackson | Orchestrator | Pipeline management |

## Learnings
{3-5 bullet points on what worked well and what to improve next time}

Step 5b: Phil Jackson — Consolidate All Agent Outputs (Auto-Trigger)

Before final ship, Phil Jackson (the orchestrator / main session) consolidates all agent outputs from the project into SCOREBOARD.md:

1. Read all files in rounds/{project}/ — debate rounds, Rick Rubin essence, board reviews, Jony/Maya reviews, Sorkin demo scripts
2. Read .planning/sara-blakely-review.md
3. Read engineering/phase-{N}-verification.md
4. Update SCOREBOARD.md with:
   • Agent participation counts (who contributed, how many reviews)
   • Quality gate results (Jony pass/fail, Maya pass/fail)
   • Board verdict summary
   • Key quotes from each agent's output

This is Phil's job as orchestrator — he sees the full picture and makes sure nothing falls through the cracks.

Step 5c: Marcus Aurelius — Retrospective (Auto-Trigger)

After Phil consolidates, spawn a haiku sub-agent as Marcus Aurelius:

Agent(model: "haiku", subagent_type: "marcus-aurelius-mod",
  prompt: "Read all project outputs: rounds/{project}/, engineering/phase-{N}-*.md, deliverables/{project}/.
  Write a Stoic retrospective:
  - What worked and why (with specific examples)
  - What didn't work and what we'd do differently
  - What we learned about our process
  - One principle to carry forward
  Be honest, not kind. The goal is growth, not comfort.
  Write to memory/{project}-retrospective.md")

The retrospective feeds into the agency's long-term memory for future projects.

Step 6: Save Operational Learnings to Memory

Write learnings to memory/ for future projects:

# Read existing memory index
cat MEMORY.md

Create or append to memory/project_{project-name}.md:

# Project: {Project Name} — Learnings

**Shipped**: {date}
**Pipeline used**: Full GSD (debate -> plan -> execute -> verify -> ship)

## What Worked
- {pattern that should be repeated}
- {tool or approach that was effective}

## What Didn't Work
- {pattern to avoid}
- {where time was wasted}

## Refined Frameworks
- {any process improvements discovered}

## Agent Performance
- {which agents excelled and why}
- {which agent configurations need tuning}

Update MEMORY.md index with a link to the new learnings file.

Step 7: Clean Up Branches

Delete merged feature branches:

# Delete local feature branches that were merged
git branch --list "feature/*" | while read branch; do
  git branch -d "$branch"
done

# Delete remote feature branches (if they exist)
git branch -r --list "origin/feature/*" | while read branch; do
  local_name="${branch#origin/}"
  git push origin --delete "$local_name" 2>/dev/null || true
done

Safety: Use git branch -d (not -D) so git refuses to delete unmerged branches.

Step 8: Verify Deploy (if applicable)

If the project has a live URL:

# Check the live deployment
curl -s -o /dev/null -w "%{http_code}" https://{live-url}
# Should return 200

# Check key endpoints
curl -s -o /dev/null -w "%{http_code}" https://{live-url}/api/health

If the deploy is through Vercel with auto-deploy on main:

1. Push main to origin: git push origin main
2. Wait 60 seconds for deploy
3. Curl the live URL to confirm
4. Check Vercel deploy status if curl fails

Report deploy verification result:

• LIVE: URL returns 200, deploy confirmed
• PENDING: Push completed, waiting for deploy pipeline
• FAILED: URL returns non-200, investigate

Step 9: Final Status Update

Set STATUS.md state back to idle (or to the next project if queued):

state: idle
last_ship: {project-name}
last_ship_date: {date}

Announce completion:

SHIP COMPLETE: {project-name}
- {X} feature branches merged to main
- {Y} tasks completed
- Deploy status: {LIVE/PENDING/FAILED}
- Ship report: deliverables/{project}/ship-report.md
- Learnings saved to memory/project_{project-name}.md

Decision Matrix

Condition	Action
Verify status is SHIP, no conflicts	Proceed with full ship
Verify status is SHIP, merge conflicts	Resolve conflicts, re-verify build, then ship
Verify status is FIX FIRST	STOP — tell user to fix and re-run /agency-verify
Verify status is BLOCK	STOP — escalate to user
Deploy fails after merge	Report failure, do NOT rollback automatically
Branch delete fails	Log warning, continue (not a blocker)

Agent Assignments

Role	Model	Purpose
Orchestrator (you)	Sonnet/Opus	Manage the full ship sequence
Deploy verifier	Haiku	Curl endpoints, check status

Key Principles

1. Ship only what's verified — never skip /agency-verify
2. Squash merge keeps history clean — one commit per feature branch on main
3. Memory makes the agency smarter — always save learnings
4. Clean up after yourself — delete merged branches
5. Verify the deploy — shipping code is not shipping product until it's live