Skip to content

porada/domfiles / skills/.domfiles-super-flow

super-flow

Verified

Coordinate a team of agents to carry out an agreed plan.

FileKindSize
SKILL.mdskill md744 B
references/super-flow.mdmarkdown17.0 KB
references/team-defaults.mdmarkdown969 B
references/team-member-instructions.mdmarkdown2.9 KB

references/super-flow.md

View on GitHub
# Super Flow

## Agree on the Work

As coordinator, discuss the target, scope, and success criteria with the user. You own the design and direction. Propose the planned series, meaning the local **commits** you want to deliver, in dependency order. Divide the work into **units**, each reviewed as a whole. A unit can contribute to several planned commits, and a commit can draw on several units. The interim commits that land a unit on the flow branch are its **checkpoints**. Use `sensible-commit-flow` with `dom-sensible-commit-flow` for planning, writing messages, and recording changes.

Use the [team profiles](team-defaults.md#profiles) to select settings for the green light. Plan a security engineer only when the work needs security engineering. Load `super-review`’s entrypoint from the installed skills root for its initial and final reviewer profiles. Its review unit is one repository and checkout. Each flow unit becomes an initial review group within the review unit for the flow worktree. Reviewers stay outside the team roster.

Use the attached worktree’s branch as the flow branch, or choose a short, available slug for a new worktree. For a proposed fast-forward, identify the separate base and its checkout, if any. Verify that the base tip is an ancestor of the proposed flow starting tip. If it isn’t, agree on a feasible starting point or delivery on the flow branch alone before the green light.

Inspect the index and working tree before reuse. Consolidation and final correction replays need a clean index and tracked working tree, with untracked and ignored files preserved. An attached thread cannot move to another worktree. If unrelated changes prevent replay, the user can handle them, approve exactly restorable isolation of their staged and unstaged state, or start the flow from a thread without a worktree. Otherwise stop.

## Obtain the Green Light

Present the scope, success criteria, proposed series, and flow units in one **Execution checkpoints** request. Ask the user explicitly whether to proceed through final handoff with all of the following effects.

- Name the roles, models, processing providers, ceiling on concurrent engineers, and expected range of team and reviewer threads. Ask whether you may add a security engineer later if a model’s safety refusal blocks in-scope work, and whether a security engineer, planned or added, may take over refused engineering work and receive the blocked engineer’s unfinished edits. Name that engineer’s model and provider. Name your interaction and runtime modes. Every member thread must inherit both so members can message you and one another. Cover disclosure of necessary non-secret repository material and task context to those participants, including direct consults, bounded engineer subagents where used, and review follow-ups, replacements, and repeats.
- Identify the flow branch, any separate base, your worktree handoff or existing binding, the engineer worktrees, and the editor’s binding. Include creating and briefing later members and relocating the flow record after a move. Name any project setup script T3 will run for a new worktree and the effects of running it. New worktrees start from commits. If a unit needs uncommitted edits from another checkout, include their transfer.
- Request local edits, validation, staging, and commits through handoff. Include append-only checkpoints, the consolidation rewrite of the flow’s own commits, moving clean private engineer branches to the rewritten tip, and folding final corrections into the series. Cover any specific state to isolate and restore for both consolidation and final correction replays.
- Specify `super-review`’s initial stage for each flow unit and its final stage for the entire consolidated series as one group, with the selected reviewer providers. Explicitly ask to prepare **and apply** the `prepush` consolidation without user review or approval of its concrete proposal.
- State the local endpoint. For delivery on the flow branch alone, specify that there is no final fast-forward. If reusing the destination itself, explain that there is no separate base and that checkpoints advance the destination before review and consolidation rewrites its flow-owned commits. For a separate base to advance, request its conditional fast-forward and identify the checkout and files it updates, or the ref-only update if checked out nowhere. Name any inherited commits it would carry and ask whether to include them. Without that approval the series stays on the flow branch. Neither endpoint includes publication.

Wait for the user’s explicit green light. Carry that answer, its limits, and its lifetime into every routed workflow. From approval to final handoff, decide sequencing, staffing within the ceiling, and in-scope corrections yourself. Return material changes to the target, scope, or agreed design to the user. An uncovered effect or human-only permission prompt still needs its own decision.

## Start the Team

Write the flow record in the starting checkout through `agent-task-directories` before you move or create any member threads. Record the approved scope and its approval reference, meaning the T3 thread and message that hold the user’s green light. Also record the flow starting tip and destination, the starting tip of any separate base, the planned series, and a map from each unit to its planned commit or commits and eventual checkpoint SHAs. Update that map as work lands. Read member status from T3.

If you need to move, make `t3_worktree_handoff` the turn’s last call. Start the flow branch from the agreed local tip with `startFromOrigin: false`. Set `runSetupScript: false` unless the green light covers the script. In the continuation prompt, give the record’s path in the original checkout, the approval reference, and the installed paths to the [entrypoint](../SKILL.md), this workflow, [Team Defaults](team-defaults.md), and [Team Member Instructions](team-member-instructions.md). Direct the resumed session to read those files and continue at team startup under the existing approval.

When setup runs in a new worktree, verify successful completion from its exit status or equivalent evidence before doing or assigning work that depends on it or could overlap its writes.

Verify the binding and starting tip. After a move, relocate the record’s task directory into the flow worktree through `agent-task-directories` and use its new path for all subsequent updates. If the original is read-only, copy the record to fresh task storage in the flow worktree, verify the copy, and report the original left behind. If you started in the flow worktree, continue with the record there.

Start the team in two phases.

1. Assign [member names and thread titles](team-defaults.md#names-and-titles) and create all required member threads idle, inheriting your modes. Bind the editor to the flow worktree. Choose every engineer’s binding from the approved concurrency ceiling, including engineers added later. At one, bind each engineer to the flow worktree. Above one, give each a private T3-created worktree from the local flow branch with `startFromOrigin: false` and a branch such as `<slug>-tim`. If creation would run an uncovered setup script that T3 cannot skip, resolve that effect before creating the worktree.
2. Once all thread identities are known, use `agent-task-relay` to send each member a brief with the complete roster of names, roles, and thread references, including yours. In every brief, give the recipient the installed path to [Team Member Instructions](team-member-instructions.md) and direct them to read it before acting. Identify the flow branch and worktree, assigned unit and checkout, write scope, expected evidence, and route back to you. Follow the same consult rules when you contact a member directly for advice. When adding an engineer later, create that thread idle and circulate the updated roster before its assignment starts.

## Land and Review Each Unit

1. **Landing.** On the member’s completion signal, verify the reported changes against the checkout, including new files and any hunks reserved for other work. Give the checkpoint a short, accurate message. In the shared worktree, coordinate writes and record it there directly. For a private worktree, follow [Land a Private Checkpoint](#land-a-private-checkpoint). Confirm the landing to the member once you have verified the checkpoint on the flow branch and mapped it to the unit.
2. **Editing.** When the landed diff contains user-surfaced text, send it to the editor in the flow worktree or edit it yourself if you hold that role. Record the edits as a further checkpoint. Give standalone documentation to the editor as its own unit.
3. **Initial review.** Invoke only `super-review`’s initial stage in the flow worktree. Select one group for the unit’s exact checkpoints, including the editor’s, and its integration boundaries. Supply a short, distinct unit label as the group label in its reviewers’ thread titles. Use the map when other checkpoints intervene. Validate findings and return each correction to its owner, including the original engineer for code. You may make a one-line correction yourself.
4. **Corrections.** Give earlier corrections priority. Corrections count toward the concurrency ceiling. If the owner is idle and the ceiling is reached, hold the correction until an engineer’s handoff lands, then start it before any new unit. If the owner is already working on a newer unit, steer their running turn with `t3_thread_send` in `steer` mode. Use their handoff to record only the earlier correction’s paths or hunks, leaving the newer edits uncommitted. If they cannot be staged apart, land them together in the newer unit’s checkpoint and map it to both units. Include that checkpoint in the earlier unit’s reassessment as well as the newer unit’s review.
5. **Clearance.** Land corrections through the same handoff, update the review targets, and follow `super-review` through clearance of each affected unit. Preserve the checkpoint history until consolidation.

Choose the sequence to fit the dependency. The same engineer can continue in order, two can work in parallel and reconcile, or a fresh engineer can start after a prerequisite lands, from a flow tip that contains it. You may wait for the predecessor’s first review reports. Weigh whether it defines a shared interface, settles an open design choice, carries uncertainty its engineer flagged, or is small compared with the dependent work.

Include reconciliation edits in the unit that lands them. Account for every change on the flow branch in a reviewed unit. Keep member threads and their context available through final clearance. When fresh context would help, add an engineer within the approved ceiling.

### Resolve a Safeguard Block

A safeguard block is a model’s or provider’s safety refusal of in-scope work. Sandbox, permission, approval, and access denials aren’t safeguard blocks and keep their existing routes.

When a member other than the security engineer reports a safeguard block, or you hit one yourself, consult the security engineer within the ceiling. A member stopped on a block isn’t using a slot. Add a security engineer first when the green light allows it. Give the security engineer the refused request and the refusal in their reported wording, limited to what that engineer’s approved disclosure covers. A consult may change the approach in substance, but it must not supply wording or content that lets the blocked agent finish the refused work.

The security engineer may take over refused engineering work only when the green light allows it, the refusal reflects the refusing model’s limits and not a rule against the work itself, and the work falls within the approved use of the security engineer’s access. If you can’t establish that, return the block to the user. Carry the refused request and the refusal into the assignment under the same limits. The security engineer’s own safeguards still apply.

Before a takeover, have the blocked engineer hand off the finished portion, and land it through the handoff for the current stage. Unfinished edits toward the refused part don’t land. Have the blocked engineer give you those edits as a patch, including new and binary files, and store it with the flow record. Verify that the patch restores them exactly on the landed tip. Only then have them cleared from the checkout, with every other change there left untouched, including staged ones. Leave them in place if you can’t verify the patch. Pass the patch to the security engineer only when the green light covers that transfer. Before consolidation, assign the rest as the security engineer’s own unit from that tip. During final corrections, route the security engineer’s fix through the final correction handoff. Return every other unresolved block to the user, including any block the security engineer reports.

A security engineer is an engineer under every rule here, including the ceiling and what engineers own. A reviewer’s block stays with `super-review`.

### Land a Private Checkpoint

Before recording, check the flow worktree and index for uncommitted edits overlapping the checkpoint’s paths. Land overlapping flow-owned edits in their unit first. Resolve unrelated obstructions with their owner. Verify that the private branch tip and the member’s reported SHA still equal the flow tip. If it advanced, return the handoff for catch-up and validation.

Record the checkpoint in the engineer’s worktree and retain its SHA with the unit. Until it lands, land nothing else. From the flow worktree, run `git merge --ff-only --no-autostash --no-overwrite-ignore <checkpoint-sha>`. If Git refuses, keep the checkpoint, clear the cause within the approved scope without advancing the flow tip, and retry only that command with the saved SHA.

## Consolidate and Finish

After every unit clears, verify the map covers all flow changes and retain the pre-consolidation tip. Load `prepush`’s installed entrypoint and run it yourself in the flow worktree. Pass the approved plan, mapped flow-owned commits, proposal waiver, rewrite authority, and any approved isolation. Exclude pending changes and history predating the flow. Have the editor write the complete messages against the proposed diffs using the commit skills. Before replay, recheck the checkout against the approved isolation plan. Apply the series once, verify exact restoration, and retain the checkpoint-to-commit mapping, including splits and combinations.

Invoke only the final stage of `super-review` in the flow worktree. Select one final group containing every consolidated commit in order, so one fresh reviewer assesses the series as a whole.

Return validated final corrections to their owners, within the concurrency ceiling. Before assigning one to an engineer with a private worktree, verify the worktree is clean and use the checkpoint map and diffs to establish that all its work is in the consolidated series. Resolve any discrepancy before moving the branch. From that engineer’s worktree, run `git checkout --no-overwrite-ignore -B <engineer-branch> <consolidated-tip>` using the checked-out branch’s name and the current consolidated SHA. This form refuses to overwrite obstructing untracked or ignored files. Stop the move on refusal. After success, verify the branch and tip before dispatch.

Land final corrections through the same member handoff, each as an appended commit. Fold them only when no final correction handoff is outstanding. A fold rewrites the series, and a private worktree with pending edits can’t follow it. Have the editor revise any message the fold makes stale. Before each final replay, recheck the checkout against the approved isolation. Fold changes and revised messages under the commit skills, verify restoration of any isolated state, and refresh the mapping. Obtain clearance on the resulting SHAs, including required repeats. Consolidate only once.

After final clearance, verify the reviewed tip. For delivery on the flow branch alone, proceed to handoff. Apply the following fast-forward only for an approved separate base.

Verify that the base still points to its recorded starting SHA, that it is an ancestor of the reviewed flow tip, and that the approval covers any inherited commits. Recheck where the base is checked out. From its approved checkout on the base branch, run `git merge --ff-only --no-autostash --no-overwrite-ignore <reviewed-tip>` and let Git refuse if the update would overwrite local changes. If the base is checked out nowhere, advance only its ref with `git update-ref refs/heads/<base> <reviewed-tip> <starting-base-tip>`. Verify that the base reached the reviewed tip. If a prerequisite is unmet or Git refuses the update, leave the series on the flow branch and report both tips and the reason. Leave publication to the user.

Settle each engineer and separate editor thread in T3 once their work is complete, preserving its history for follow-ups. At final handoff, report the series in order, the pre-consolidation tip, the old-to-final mapping, deviations from the plan, the destination branch and any base update, the flow record’s path, and the worktrees and branches left behind. Identify any remaining action or settlement limitation.
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall