Skip to content

eric-cielo/moflo / .claude/skills/fl

MoFlo ticket spell - analyze and execute GitHub issues

FileKindSize
SKILL.mdskill md17.5 KB
epic.mdmarkdown2.1 KB
execution-modes.mdmarkdown4.4 KB
phases.mdmarkdown22.8 KB
sdd.mdmarkdown7.8 KB
spell-engine.mdmarkdown1.8 KB
ticket.mdmarkdown6.0 KB

execution-modes.md

View on GitHub
# Execution Mode Details

The execution mode chooses how work is carried out across the phases. Pass `-s/--swarm`, `-h/--hive`, or `-n/--normal` (default).

The SDD/verify modifiers (`-sd`/`--sdd`, `-v`/`--verify` — see `./sdd.md`) are **orthogonal** to execution mode: they change *what stages run* (spec/plan front-half, verify-before-done), not *how work is carried out*. So `--sdd -s` runs the spec→plan→implement→verify cycle with a swarm carrying out the implement/test phases. Note `-sd` (SDD) is a distinct token from `-s` (swarm) — they compose, they don't collide.

## SWARM mode (`-s`, `--swarm`)

> **MANDATORY when `-s` is passed.** Your first Execute-phase action MUST be `mcp__moflo__swarm_init`, followed by `mcp__moflo__agent_spawn` for each role. Spawning subagents via `Agent` (or `Task`) without first registering the swarm is a violation of the swarm-registration contract. The `Agent` PreToolUse gate will BLOCK the call until `swarm_init` runs. Even when you also use `Agent` for parallelism, the moflo swarm IS the registration surface — call it first. See CLAUDE.md "⛔ Protected functionality — swarm + hive-mind".

> **`-s` is the user's request for agents.** An ambient "don't call the Agent
> tool unless the user requested it" is satisfied by the flag — dispatch.
> `swarm_init`/`agent_spawn` are MCP tools, so a suppressed run still registers a
> swarm and passes the registration gate while dispatching nobody. If you cannot spawn
> `Agent`, say so and stop.

Swarm mode coordinates agents through the moflo swarm coordinator, then spawns workers via the `Agent` tool.

Roles:
- `researcher` — analyzes the issue, searches memory, finds patterns
- `coder` — implements changes following the plan
- `tester` — writes and runs tests
- `/flo-simplify` — moflo's adaptive code review skill (sized to diff, parallel agents on big changes)
- `reviewer` — reviews code before PR

Required pattern:
```javascript
// 1. Create the task list first
TaskCreate({ subject: "📋 [Researcher] Research issue", ... })
TaskCreate({ subject: "💻 [Coder] Implement changes", ... })
TaskCreate({ subject: "🧪 [Tester] Test implementation", ... })
TaskCreate({ subject: "🔍 [Reviewer] Run /flo-simplify on changed files", ... })

// 2. Init the swarm — MANDATORY, gate-enforced
mcp__moflo__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })

// 3. Register each agent with the coordinator — MANDATORY
mcp__moflo__agent_spawn({ type: "researcher", ... })
mcp__moflo__agent_spawn({ type: "coder", ... })
mcp__moflo__agent_spawn({ type: "tester", ... })
mcp__moflo__agent_spawn({ type: "reviewer", ... })

// 4. Now safe to dispatch via Agent tool for parallel execution
Agent({ prompt: "...", subagent_type: "researcher", run_in_background: true })
Agent({ prompt: "...", subagent_type: "coder", run_in_background: true })

// 5. Wait for results, synthesize, continue
```

## HIVE-MIND mode (`-h`, `--hive`)

> **MANDATORY when `-h` is passed.** Your first Execute-phase action MUST be `mcp__moflo__hive-mind_init`. The `Agent` PreToolUse gate will BLOCK any subagent spawn until hive-mind init has run. See CLAUDE.md "⛔ Protected functionality — swarm + hive-mind".

> **`-h` is the user's request for agents** — same as SWARM above. One context
> cannot form a consensus; if you cannot spawn `Agent`, say so and stop.

Use for consensus-based decisions:
- Architecture choices
- Approach tradeoffs
- Design decisions with multiple valid options

Required pattern:
```javascript
// 1. Init the hive — MANDATORY, gate-enforced
mcp__moflo__hive-mind_init({ ... })

// 2. Spawn workers + reach consensus via mcp__moflo__hive-mind_consensus
mcp__moflo__hive-mind_spawn({ ... })
mcp__moflo__hive-mind_consensus({ ... })
```

## NORMAL mode (default)

Single Claude execution without spawning sub-agents.
- Still uses TaskCreate for tracking
- Still creates tasks for visibility
- Post-task neural learning hooks still fire
- No agent spawning, no swarm/hive init required

## Why these are MANDATORY

Swarm and hive-mind are headline moflo product surface (CLAUDE.md "⛔ Protected functionality"). When the user explicitly opts in via `-s`/`-h`, the protected MCP surface MUST be exercised — falling back to "Claude-native parallelism" via `Agent` tool calls without coordinator registration is the failure mode this rule exists to prevent. The PreToolUse gate enforces this; opt-out is `gates.swarm_invocation_gate: false` in `moflo.yaml`.
planning-and-task-breakdownaddyosmani/agent-skillsBreaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
screenpipethedotmack/claude-memSearch screen and audio history recorded by Screenpipe and optionally save selected context into claude-mem. Use when the user asks to recall desktop activity, a meeting, or something seen in another app through Screenpipe.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
contact-widgetnexu-io/open-designSelf-contained floating chat widget with welcome screen, social links, meeting button, and message input. Single HTML file, zero dependencies.Stars: 108kUpdated Claude CodeCodexVerifiedInstall
meeting-notesnexu-io/open-designMeeting notes page — title bar with attendees, agenda checklist, decisions block, action items table with owners + dates, and a "next meeting" footer. Use when the brief mentions "meeting notes", "minutes", "1:1 notes", "all-hands recap", or "会议纪要".Stars: 108kUpdated Claude CodeCodexVerifiedInstall