pre-publish-review skill

Pre-Publish Review — 12-Agent Release Gate

Three-agent-layer review before publishing to npm. Every layer covers a different angle, and every result is mapped onto the release layers below.

Release Layer Taxonomy

Every phase classifies evidence and risk across:

Phase 0: Detect Unpublished Changes

Run /get-unpublished-changes FIRST. This is the single source of truth for what changed and must include omo pure components, omo opencode, and omo codex layer-specific version recommendations.

skill(name="get-unpublished-changes")

This command automatically:

• Detects published npm version vs local version
• Lists all commits since last release
• Reads actual diffs (not just commit messages) to describe REAL changes
• Groups changes by type (feat/fix/refactor/docs) with scope
• Identifies breaking changes
• Recommends a layer-specific version bump plus one overall workflow bump

Save the full output — it feeds directly into Phase 1 grouping and all agent prompts.

Then capture raw data needed by agent prompts:

# Extract versions (already in /get-unpublished-changes output)
PUBLISHED=$(npm view oh-my-opencode version 2>/dev/null || echo "not published")
LOCAL=$(node -p "require('./package.json').version" 2>/dev/null || echo "unknown")

# Raw data for agents (diffs, file lists)
COMMITS=$(git log "v${PUBLISHED}"..HEAD --oneline 2>/dev/null || echo "no commits")
COMMIT_COUNT=$(echo "$COMMITS" | wc -l | tr -d ' ')
DIFF_STAT=$(git diff "v${PUBLISHED}"..HEAD --stat 2>/dev/null || echo "no diff")
CHANGED_FILES=$(git diff --name-only "v${PUBLISHED}"..HEAD 2>/dev/null || echo "none")
FILE_COUNT=$(echo "$CHANGED_FILES" | wc -l | tr -d ' ')

If PUBLISHED is "not published", this is a first release — use the full git history instead.

Phase 1: Parse Changes into Groups

Use the /get-unpublished-changes output as the starting point — it already groups by scope and type.

Grouping strategy:

1. Start from the /get-unpublished-changes analysis which already categorizes by feat/fix/refactor/docs with scope
2. Further split by module/area — changes touching the same module or feature area belong together
3. Target up to 10 groups. If fewer than 10 commits, each commit is its own group. If more than 10 logical areas, merge the smallest groups.
4. For each group, extract:

• Group name: Short descriptive label (e.g., "agent-model-resolution", "hook-system-refactor")
• Release layer(s): omo pure components, omo opencode, omo codex
• Commits: List of commit hashes and messages
• Files: Changed files in this group
• Diff: The relevant portion of the full diff (git diff v${PUBLISHED}..HEAD -- {group files})

Phase 2: Spawn All Agents

Launch ALL agents in a single turn. Every agent uses runinbackground=true. No sequential launches.

Layer 1: Ultrabrain Per-Change Analysis (up to 10)

For each change group, spawn one ultrabrain agent. Each gets only its portion of the diff — not the full changeset.

task(
  category="ultrabrain",
  model="gpt-5.6-sol",
  run_in_background=true,
  load_skills=[],
  description="Deep analysis: {GROUP_NAME}",
  prompt="""
<review_type>PER-CHANGE DEEP ANALYSIS</review_type>
<change_group>{GROUP_NAME}</change_group>

<project>oh-my-opencode (npm package)</project>
<published_version>{PUBLISHED}</published_version>
<target_version>{LOCAL}</target_version>

<commits>
{GROUP_COMMITS — hash and message for each commit in this group}
</commits>

<changed_files>
{GROUP_FILES — files changed in this group}
</changed_files>

<diff>
{GROUP_DIFF — only the diff for this group's files}
</diff>

<file_contents>
{Read and include full content of each changed file in this group}
</file_contents>

You are reviewing a specific subset of changes heading into an npm release. Focus exclusively on THIS change group. Other groups are reviewed by parallel agents.

ANALYSIS CHECKLIST:

1. **Intent Clarity**: What is this change trying to do? Is the intent clear from the code and commit messages? If you have to guess, that's a finding.

2. **Correctness**: Trace through the logic for 3+ scenarios. Does the code actually do what it claims? Off-by-one errors, null handling,

Layer 2: Holistic Review via /review-work (one gate reviewer)

Spawn a sub-agent that loads the /review-work skill. The review-work skill runs manual QA on the real surface itself, then launches ONE gate reviewer (oracle) that audits goal compliance, code quality, security, missed context, and the QA evidence. The review passes only on a clean QA matrix plus APPROVE.

task(
  category="unspecified-high",
  model="gpt-5.6-sol",
  run_in_background=true,
  load_skills=["review-work"],
  description="Run /review-work on all unpublished changes",
  prompt="""
Run /review-work on the unpublished changes between v{PUBLISHED} and HEAD.

GOAL: Review all changes heading into npm publish of oh-my-opencode. These changes span {COMMIT_COUNT} commits across {FILE_COUNT} files.

CONSTRAINTS:
- This is a plugin published to npm — public API stability matters
- TypeScript strict mode, Bun runtime
- No `as any`, `@ts-ignore`, `@ts-expect-error`
- Factory pattern (createXXX) for tools, hooks, agents
- kebab-case files, barrel exports, no catch-all files

BACKGROUND: Pre-publish review of oh-my-opencode, an OpenCode plugin with 1268 TypeScript files, 160k LOC. Changes since v{PUBLISHED} are about to be published.

The diff base is: git diff v{PUBLISHED}..HEAD

Follow the /review-work skill flow exactly — run the manual QA phase, launch the gate reviewer, and collect its verdict. Do NOT skip the QA phase or the reviewer.
""")

Layer 3: Oracle Release Synthesis (1 agent)

The oracle gets the full picture — all commits, full diff stat, and changed file list. It provides the final release readiness assessment.

task(
  subagent_type="oracle",
  model="gpt-5.6-sol",
  run_in_background=true,
  load_skills=[],
  description="Oracle: overall release synthesis and version bump recommendation",
  prompt="""
<review_type>RELEASE SYNTHESIS — OVERALL ASSESSMENT</review_type>

<project>oh-my-opencode (npm package)</project>
<published_version>{PUBLISHED}</published_version>
<local_version>{LOCAL}</local_version>

<all_commits>
{ALL COMMITS since published version — hash, message, author, date}
</all_commits>

<diff_stat>
{DIFF_STAT — files changed, insertions, deletions}
</diff_stat>

<changed_files>
{CHANGED_FILES — full list of modified file paths}
</changed_files>

<full_diff>
{FULL_DIFF — the complete git diff between published version and HEAD}
</full_diff>

<file_contents>
{Read and include full content of KEY changed files — focus on public API surfaces, config schemas, agent definitions, hook registrations, tool registrations}
</file_contents>

You are the final gate before an npm publish. 10 ultrabrain agents are reviewing individual changes and the review-work gate reviewer is doing the holistic review. Your job is the bird's-eye view that those focused reviews might miss.

SYNTHESIS CHE

Phase 3: Collect Results

As agents complete (system notifications), collect via backgroundoutput(taskid="...").

Track completion in a table:

Do NOT deliver the final report until ALL agents have completed.

Phase 4: Final Verdict

BLOCK if:

• Oracle verdict is BLOCK
• Any ultrabrain found CRITICAL blocking issues
• Review-work failed on any MAIN agent

RISKY if:

• Oracle verdict is RISKY
• Multiple ultrabrains returned CAUTION or FAIL
• Review-work passed but with significant findings

CAUTION if:

• Oracle verdict is CAUTION
• A few ultrabrains flagged minor issues
• Review-work passed cleanly

SAFE if:

• Oracle verdict is SAFE
• All ultrabrains passed
• Review-work passed

Compile the final report:

# Pre-Publish Review — oh-my-opencode

## Release: v{PUBLISHED} -> v{LOCAL}
**Commits:** {COMMIT_COUNT} | **Files Changed:** {FILE_COUNT} | **Agents:** {AGENT_COUNT}

---

## Overall Verdict: SAFE / CAUTION / RISKY / BLOCK

## Recommended Version Bump: PATCH / MINOR / MAJOR
{Justification from Oracle}

## Layer-specific Version Recommendation

| Layer | Recommendation | Reason |
|---|---|---|
| omo pure components | PATCH/MINOR/MAJOR | ... |
| omo opencode | PATCH/MINOR/MAJOR | ... |
| omo codex | PATCH/MINOR/MAJOR | ... |

---

## Per-Change Analysis (Ultrabrains)

| # | Change Group | Verdict | Risk | Breaking? | Blocking Issues |
|---|-------------|---------|------|-----------|-----------------|
| 1 | {name} | PASS/FAIL | SAFE/CAUTION/RISKY | YES/NO | {count or "none"} |
| ... | ... | ... | ... | ... | ... |

### Blocking Issues from Per-Change Analysis
{Aggregated from all ultrabrains — deduplicated}

---

## Holistic Review (Review-Work)

| # | Review Area | Verdict | Confidence |
|---|------------|---------|------------|
| 1 | Manual QA (orchestrator, real surface) | PASS/FAIL | - |
| 2 | Gate Review (goal, code quality, security, context, QA audit) | APPROVE/REJECT | HIGH/ME

Anti-Patterns