RonanCodes/skills/ultracode

Ultracode

Say the word, the sub-agents fan out. This skill is the bridge from "here's what's left to do" to a running Workflow-tool orchestration — it computes the work-list and order, writes a bespoke Workflow JS script tuned to that list, and invokes it. The word ultracode is the explicit opt-in the Workflow tool requires, so invoking this skill authorises the run.

Relationship to the rest of the kit:

• /ro:project-status produces the build queue this skill consumes. If no queue exists, ultracode runs it first.
• /ro:night-shift / /ro:planner-worker drain a backlog with the Agent tool (model-driven loop). Ultracode uses the Workflow tool (deterministic JS: explicit phases, fan-out, barriers, per-item pipelines). Reach for ultracode when you want a scripted orchestration shaped to a known roadmap; reach for night-shift when you want an open-ended multi-wave drain.

This is a long autonomous run → it fires /ro:pushover + /ro:telegram at the end (firing rule condition 4), and writes a /ro:completion-report first so the ping deep-links to the diff browser.

Step 1 — Resolve the work-list

In priority order:

1. Explicit goal (/ro:ultracode "build the comparables offer model") → scope that single goal into a workflow (design → implement → verify), not a queue drain.
2. --from-queue or default → read .handoff/status-latest.md ## Build queue. If missing, run /ro:project-status first to generate it.
3. --from-issues → gh issue list --label ready-for-agent --state open.

Cap with --max <n> (default: the whole ready queue). --plan-only writes the script and prints the plan but does not invoke Workflow.

Step 2 — Order + conflict-partition

For a queue: order by dependency (a slice another needs comes first; respect PRD slice order) and the night-shift 4-signal rank (age + priority + size + unblocks-others). Then partition by file-area overlap — slices that touch disjoint paths run in parallel; slices that touch the same area serialise. This is the hybrid conflict detection from the factory pattern. Worktree isolation (isolation: 'worktree') is the backstop so parallel writers never clobber a shared tree.

Step 3 — Author the Workflow script

Write a self-contained script (see template below), tuned to the resolved list, then invoke the Workflow tool with it (pass it inline via script). The tool persists the script to disk and returns a path; iterate by editing that file and re-invoking with scriptPath.

The script MUST encode this repo's conventions (read the repo CLAUDE.md first and bake the specifics in):

• Commits: emoji conventional, no Co-Authored-By; weekday commits timestamped outside 08:30–18:00 (set GIT_AUTHOR_DATE/GIT_COMMITTER_DATE).
• Ship: per slice → branch → PR → squash-merge via the repo's gate (/ro:ship); a close-with-summary comment on the issue before merge; Closes #N in the PR body. --pr-only stops at open PRs (no merge) for human review.
• Verify: after merge, confirm the deploy (/ro:vercel-verify on Vercel repos) — a green local gate is not a green deploy.

Workflow script template

Fill the bracketed parts from steps 1–2. Keep meta a pure literal.

export const meta = {
  name: 'ultracode-<slug>',
  description: '<one-line goal or "drain N-slice build queue">',
  phases: [
    { title: 'Plan' },
    { title: 'Implement' },
    { title: 'Review' },
    { title: 'Merge' },
  ],
}

const SLICES = [ /* {issue, title, area, deps} from step 2, in order */ ]
const PR_ONLY = <true|false from --pr-only>

phase('Plan')
// one planner pass: confirm scope + acceptance per slice (schema-validated)
const plan = await agent(`Plan the slices: ${JSON.stringify(SLICES)}. For each, return acceptance criteria + the files it will touch.`, { schema: PLAN_SCHEMA })

// implement → review run as a PER-ITEM pipeline (no barrier); worktree isolation since they write in parallel
const results = await pipeline(
  plan.slices,
  s => agent(
    `Implement slice #${s.issue}: ${s.title}. Acceptance: ${s.acceptance}. ` +
    `Follow repo CLAUDE.md: emoji conventional commit, NO Co-Authored-By, weekday timestamps outside 08:30-18:00. ` +
    `Open a branch, implement, post a close-with-summary comment on #${s.issue}, open a PR with "Closes #${s.issue}".`,
    { label: `impl:#${s.issue}`, phase: 'Implement', isolation: 'worktree', schema: IMPL_SCHEMA }
  ),
  (impl, s) => agent(
    `Adversarially review PR for slice #${s.issue} against its acceptance criteria. Return verdict + blocking findings.`,
    { label: `review:#${s.issue}`, phase: 'Review', schema: REVIEW_SCHEMA }
  ).then(v => ({ ...impl, issue: s.issue, review: v })),
)

// Merge stage: SERIAL (parallel squash-merges to main race). Skip if PR_ONLY.
phase('Merge')
const merged = []
for (const r of results.filter(Boolean).filter(r => r.review?.pass)) {
  if (PR_ONLY) continue
  const m = await agent(`Squash-merge PR for #${r.issue} via the repo gate (/ro:ship style: gh pr merge --squash --admin), then verify the deploy reached READY.`, { label: `merge:#${r.issue}`, phase: 'Merge', schema: MERGE_SCHEMA })
  merged.push({ issue: r.issue, ...m })
}

return { planned: plan.slices.length, merged: merged.length, prOnly: PR_ONLY, results }

Define the *_SCHEMA JSON-Schema consts above meta is not allowed (meta must be first and a pure literal) — declare schemas in the body after meta. Scale agent count to the queue size; the Workflow tool caps concurrency automatically. For a single explicit goal, collapse to: Plan → one Implement agent → 3-vote adversarial Verify → Merge.

Step 4 — Report + ping

When Workflow returns, summarise (planned / merged / PR-only / blocked), then for a real (non---plan-only) run write a /ro:completion-report --no-open and fire /ro:pushover + /ro:telegram with --url file://<report> so the phone notification opens the diff browser. State + one metric + next action (e.g. "ultracode done — 5/6 slices merged, #34 bounced on review").

Guardrails

• The word ultracode is the opt-in. Don't author/run a Workflow from this skill unless the user actually said it (or invoked /ro:ultracode).
• Never push to main directly — branch → PR per slice, even on solo repos.
• --pr-only for anything risky. When the queue touches auth, migrations, or money, default to PR-only and let the user merge.
• Respect repo-mode — on a work repo, no GitHub side-effects (mirror to local .ralph/ per /ro:planner-worker's rule); this skill's GH-PR flow is for personal repos.