rbin-task-flow 1.26.1 → 1.27.1

package/.claude/skills/task-flow-split/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: task-flow-split
+description: Plans N parallel IA streams from pending tasks (split:N required). Non-conflicting areas, ordered by difficulty, outputs task-flow run X,Y,Z per tier. Use for task-flow split:3, split:2, dividir em 3 ias — not plain split.
+disable-model-invocation: false
+paths: [".task-flow/**"]
+---
+
+# Task Flow — Split
+
+## Status
+
+!`head -20 .task-flow/tasks.status.md 2>/dev/null || echo "Run sync first"`
+
+## Steps
+
+1. Parse **`split:N`** — N required (e.g. `split:3`). Plain `split` without `:N` → ask user. Optional scope: `split:3 50-72` or `split:2 50,51`.
+2. Load pending IDs from `status.json`; read `tasks.json` for those tasks.
+3. Partition into **N** non-conflicting streams; keep dependency chains together.
+4. Order streams IA-1 (strongest) → IA-N by difficulty.
+5. Output **N lines:** `task-flow: run id,id,id` + coordination notes.
+6. **Do not** implement or update status.
+
+Reference: `.cursor/rules/task_split.mdc`

package/.cursor/rules/task-flow-cursor.mdc

@@ -23,6 +23,7 @@ alwaysApply: true
 | `task-flow: sync` | `@task-flow-sync` or [task-flow-sync.mdc](mdc:.cursor/rules/task-flow-sync.mdc) |
 | `task-flow: from contexts` | `@task-flow-from-contexts` |
 | `task-flow: run next X`, `run N` | `@task-flow-run` |
+| `task-flow: split:N` | `@task-flow-split` |
 | `task-flow: status` | `@task-flow-status` |
 | `task-flow: audit` | `@task-flow-audit` |
 | `task-flow: validate` | `@task-flow-validate` |

package/.cursor/rules/task_execution.mdc

@@ -14,6 +14,7 @@ alwaysApply: false
 | `task-flow: sync` | `@task-flow-sync` |
 | `task-flow: from contexts` | `@task-flow-from-contexts` |
 | `task-flow: run next X`, `run N` | `@task-flow-run` |
+| `task-flow: split:N` | `@task-flow-split` |
 | `task-flow: status` | `@task-flow-status` |
 | `task-flow: audit` | `@task-flow-audit` |
 | `task-flow: validate` | `@task-flow-validate` |

package/.cursor/rules/task_split.mdc

@@ -0,0 +1,112 @@
+---
+description: Plans parallel task-flow run across N AIs — split:N required. Splits pending tasks into non-conflicting streams ordered by difficulty. Use for task-flow split:3, split:2, etc.
+alwaysApply: false
+---
+
+# task-flow: split:N
+
+**Prefer:** `@task-flow-split` · **Does not implement** — only outputs copy-paste `task-flow: run X,Y,Z` per IA tier.
+
+**`N` is required.** Plain `task-flow: split` (without `:N`) is invalid — ask for `split:2`, `split:3`, etc.
+
+## When to run
+
+- `task-flow: split:3` — all pending, 3 IAs
+- `task-flow: split:2` — all pending, 2 IAs
+- `task-flow: split:3 50-72` — scope range, 3 IAs
+- `task-flow: split:2 50,51,69` — scope list, 2 IAs
+
+Natural language: `dividir pending em 3 ias` → `split:3`.
+
+Default scope (no trailing ids): **all tasks with any pending subtask** in `status.json`.
+
+## What it does NOT do
+
+- Does **not** run subtasks or edit `status.json` / `tasks.json`
+- Does **not** replace `task-flow: run` — user pastes each output line into a separate IA session
+
+## Process
+
+### 1. Parse N and scope
+
+- **N:** integer ≥1 from `split:N` (typical 2–4)
+- **Scope:** optional `50-72` or `50,51,69` after `split:N`
+- If `N` missing or invalid, stop and show examples
+
+### 2. Load pending scope
+
+- Read `status.json` — task IDs with ≥1 `pending` or `in_progress` subtask
+- Filter by scope if provided
+- Read matching tasks from `tasks.json`
+- If zero pending, report and stop
+
+### 3. Infer touch areas (conflict detection)
+
+Per task, infer **primary file/module areas** from subtask `instructions` and task text.
+
+Optional: `graphify query` when `.task-flow/guides/graphify-out/graph.json` exists.
+
+Two tasks **conflict** if they likely edit the **same files or same service/module** in parallel.
+
+### 4. Detect dependency chains
+
+Sequential / dependent tasks → **same stream**, **ascending ID order**. Never split a chain across IAs.
+
+### 5. Partition into N streams
+
+Goal: **up to N** non-overlapping streams.
+
+1. Group conflicting tasks in the same stream
+2. Balance into **N** streams with minimal cross-stream overlap
+3. If pending tasks < N, output that many streams only (no empty streams)
+
+### 6. Order streams by difficulty (IA tier)
+
+Strongest model → **IA-1**, then IA-2 … IA-N:
+
+| Position | Typical content |
+|----------|-----------------|
+| IA-1 (strongest) | Auth, migrations, Firestore rules, money/idempotency, architecture |
+| Mid tiers | Feature work, integrations |
+| IA-N (lightest) | UI tweaks, verification, docs, small fixes |
+
+Within each stream: task IDs **ascending**.
+
+### 7. Output (required format)
+
+```markdown
+## Task Flow Split (:3)
+
+**Pending in scope:** N tasks · **Streams:** 3
+
+### 🟣 IA-1 — strongest (…)
+task-flow: run 58,61,62,63,64,65,66,67,68
+
+### 🟢 IA-2 — (…)
+task-flow: run 50,51,59,53,60
+
+### 🔵 IA-3 — (…)
+task-flow: run 52,54,55,56,57,69,70,71,72
+
+### ⚠️ Coordination
+- …
+
+### Next
+Paste one block per IA session. `task-flow: status`
+```
+
+For `split:2`, use two tiers (🟣 IA-1, 🟢 IA-2). For `split:4`, add 🟡 IA-4, etc.
+
+One **`task-flow: run id,id,id`** line per stream.
+
+### 8. Coordination notes
+
+Call out shared files between streams, read-after-write deps, and ordering inside each list.
+
+## Integration
+
+- Execute: `@task-flow-run` per stream
+- Status: `@task-flow-status`
+- Git: [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc)
+
+**Principle:** `split:N` = plan N parallel `run` commands; user owns N sessions; no execution.

package/.task-flow/README.md

@@ -81,6 +81,7 @@ Guia completo: [guides/GRAPHIFY.md](guides/GRAPHIFY.md).
 | `task-flow: validate` | `all` (default) · `X` · `X,Y` | Deep audit vs codebase; revert false done; append gaps to `tasks.input.txt`; sync |
 | `task-flow: status` | — | Shows current task status |
 | `task-flow: run` | `next X` · `X` · `X,Y` · `all` | Execute pending subtasks: next N in order, one/many tasks, or everything |
+| `task-flow: split` | `:3` · `:2` · `:3 50-72` | Plan **N** parallel `run` lines — `:N` required |
 | `task-flow: estimate` | `X` · `X,Y` · `all` | Time estimate for average developer pace (hours + management buffer) |
 | `task-flow: report` | `X` · `X,Y` · `all` | Implementation report → `.task-flow/guides/reports/task-X-implementation.md` |
 | `task-flow: audit` | — | Audits codebase against **coding standards checklist**; full doc on demand |
@@ -126,6 +127,15 @@ Audits the **entire codebase** against the **checklist** in [coding_standards.md
 
 ## Commands with Task ID
 
+### `task-flow: split:N`
+Plans **parallel work across N IAs** (`split:3`, `split:2`, …). **`:N` is required** — plain `split` is invalid.
+
+**Examples:**
+- `task-flow: split:3` — all pending, 3 streams
+- `task-flow: split:2 50-72` — range, 2 streams
+
+Output: N copy-paste lines `task-flow: run id,id,id` + coordination notes. Invoke: `@task-flow-split`.
+
 ### `task-flow: run next X`
 Works on next X pending subtasks in sequential order. Implements and marks as "done".
 

package/.task-flow/guides/AI-PLATFORMS.md

@@ -33,8 +33,9 @@ Os comandos `task-flow: …` são **os mesmos** em Claude Code, Cursor e Codex.
 1. Definir tasks: editar `tasks.input.txt` **ou** colocar specs em `contexts/` e rodar `task-flow: from contexts`
 2. `task-flow: sync`
 3. `task-flow: status`
-4. `task-flow: run next X` ou `task-flow: run N`
-5. **Você** faz `git commit` (a IA só sugere)
+4. `task-flow: split:3` (opcional — N IAs em paralelo) → colar cada `run X,Y,Z` numa sessão
+5. `task-flow: run next X` ou `task-flow: run N`
+6. **Você** faz `git commit` (a IA só sugere)
 
 Detalhes dos comandos: [README.md](../README.md).
 
@@ -55,7 +56,7 @@ Detalhes dos comandos: [README.md](../README.md).
 | `.codex/config.toml` | — | — | ✅ (opcional, preservado no update) |
 | `task-flow-cursor.mdc` | — | ✅ always-on | — |
 | `rbin-git-policy.mdc` | — | ✅ always-on | — |
-| `.claude/skills/` | ✅ (10 skills) | — | — |
+| `.claude/skills/` | ✅ (11 skills) | — | — |
 | `.cursor/skills/` | — | ✅ (espelho) | — |
 
 Por padrão, `.claude/`, `.cursor/`, `.task-flow/`, `CLAUDE.md` e `AGENTS.md` entram no **`.gitignore`** do projeto cliente. Para versionar skills/regras com o time, ajuste o ignore — veja a seção “Versionamento” em cada guia.

package/.task-flow/guides/CODEX.md

@@ -29,6 +29,19 @@ Rule: `.cursor/rules/task_from_contexts.mdc`
 
 ---
 
+## task-flow: split:N
+
+1. **N obrigatório** — `split:3`, `split:2`. `split` sem `:N` → inválido.
+2. Escopo opcional: `split:3 50-72` ou `split:2 50,51,69`; senão todas pending.
+3. Particionar em **N** filas sem conflito; cadeias na mesma fila.
+4. Ordenar IA-1 (mais forte) → IA-N por dificuldade.
+5. Output N linhas `task-flow: run id,id,id` + coordenação.
+6. **Não** implementar nem editar status.
+
+Rule: `.cursor/rules/task_split.mdc`
+
+---
+
 ## task-flow: run next X | run X | run all
 
 See AGENTS.md **Run** section. Prefer `.claude/skills/task-flow-run/workflow.md`; fallback: `.cursor/rules/task_work.mdc`.

package/.task-flow/guides/CURSOR.md

@@ -23,6 +23,7 @@ Verify: `rg 'alwaysApply: true' .cursor/rules` → only the two files above.
 |---------------------|-------------|
 | `task-flow: from contexts` | `@task-flow-from-contexts` |
 | `task-flow: sync` | `@task-flow-sync` |
+| `task-flow: split:N` | `@task-flow-split` |
 | `task-flow: run next 4` | `@task-flow-run` |
 | `task-flow: status` | `@task-flow-status` |
 | `task-flow: validate` | `@task-flow-validate` |

package/.task-flow/guides/platforms/claude-code.md

@@ -29,7 +29,7 @@ projeto/
 ├── CLAUDE.md                 # Índice enxuto + tabela de skills
 ├── .claude/
 │   ├── settings.json
-│   └── skills/               # 10 skills (task-flow-*, rbin-*)
+│   └── skills/               # 11 skills (task-flow-*, rbin-*)
 ├── .cursor/
 │   ├── rules/                # Referência + Cursor alwaysApply
 │   └── skills/               # Espelho das mesmas skills
@@ -144,6 +144,7 @@ Para Task Flow em equipe: prefira **skills de projeto** versionadas (ajuste o `.
 | `task-flow: from contexts` | `task-flow-from-contexts` | `/task-flow-from-contexts` | `task_from_contexts.mdc` |
 | `task-flow: sync` | `task-flow-sync` | `/task-flow-sync` | `task-flow-sync.mdc` · `task_generation.mdc` (subtasks) |
 | `task-flow: run next X` / `run X` | `task-flow-run` | `/task-flow-run` | `workflow.md` · stub `task_work.mdc` |
+| `task-flow: split:N` | `task-flow-split` | `/task-flow-split` | `task_split.mdc` |
 | `task-flow: status` | `task-flow-status` | `/task-flow-status` | `task_status.mdc` |
 | `task-flow: audit` | `task-flow-audit` | `/task-flow-audit` | `task_audit.mdc` |
 | `task-flow: estimate X` / `X,Y` / `all` | `task-flow-estimate` | `/task-flow-estimate` | `task_estimate.mdc` |
@@ -318,7 +319,7 @@ Ou use `AGENTS.override.md` / settings locais fora do git e commite `.claude/ski
 ## 13. Checklist de maturidade Claude + Task Flow
 
 - [x] `CLAUDE.md` enxuto com índice de skills
-- [x] Skills instaladas via `rbin-task-flow init` (10 skills)
+- [x] Skills instaladas via `rbin-task-flow init` (11 skills)
 - [x] `paths: [".task-flow/**"]` em `task-flow-run`, `sync`, `estimate`, `report`
 - [x] Injeção `` !`head tasks.status.md` `` em `task-flow-run`
 - [ ] `.claude/skills/` versionado no git (ajustar `.gitignore` se o time quiser)

package/.task-flow/guides/platforms/codex.md

@@ -154,6 +154,7 @@ Codex prefere `AGENTS.override.md` sobre `AGENTS.md` **no mesmo nível**.
 | Comando | Prompt mínimo eficaz |
 |---------|---------------------|
 | `task-flow: from contexts` | `task_from_contexts.mdc — leia contexts/, append tasks em tasks.input.txt` |
+| `task-flow: split:N` | `task_split.mdc — split:3 ou split:2 50-72, output task-flow: run id,id,id` |
 | `task-flow: sync` | `Leia AGENTS.md e task-flow-sync.mdc. Execute task-flow: sync em tasks.input.txt.` |
 | `task-flow: run next 3` | `Siga task-flow-run workflow.md. task-flow: run next 3. Atualize status.json e tasks.status.md.` |
 | `task-flow: run 2` | Idem + respeitar dependências tasks 1..X-1 |

package/.task-flow/guides/platforms/cursor.md

@@ -8,7 +8,7 @@ Guia para extrair o máximo do **RBIN Task Flow** no [Cursor](https://cursor.com
 
 ## 1. Por que o Task Flow “nasce” bem no Cursor
 
-O instalador copia regras para `.cursor/rules/` e **10 skills** para `.cursor/skills/`. Desde **v1.23** (otimização P0 — ver [OPTIMIZATION-PLAN.md](../OPTIMIZATION-PLAN.md)):
+O instalador copia regras para `.cursor/rules/` e **11 skills** para `.cursor/skills/`. Desde **v1.23** (otimização P0 — ver [OPTIMIZATION-PLAN.md](../OPTIMIZATION-PLAN.md)):
 
 | Camada | O que carrega | Tokens (~) |
 |--------|----------------|------------|
@@ -71,6 +71,7 @@ Confirme no projeto: `rg 'alwaysApply: true' .cursor/rules` → deve listar **ap
 | `task_work.mdc` | fallback curto de `run` | Intelligent — use `@task-flow-run` |
 | `task_execution.mdc` | índice stub → skills | Intelligent / `@` manual |
 | `task_from_contexts.mdc` | draft tasks de `contexts/` | Intelligent |
+| `task_split.mdc` | plano paralelo `split:N` | Intelligent |
 | `task-flow-sync.mdc` | `sync` completo | **Glob** `.task-flow/**` · prefer `@task-flow-sync` |
 | `task_generation.mdc` | templates de subtarefas | **Glob** `.task-flow/**` |
 | `task_status.mdc` | `status` | **Glob** `.task-flow/**` |
@@ -108,7 +109,7 @@ Cursor suporta o mesmo formato que Claude Code: `.cursor/skills/<nome>/SKILL.md`
 | Mesmo workflow em Claude + Cursor | Skills em **ambas** pastas | ✅ |
 | Referência enorme (coding standards) | checklist glob (~1k tokens) | `@rbin-coding-standards` + full doc por seção |
 
-O `rbin-task-flow init` copia **10 skills** para `.cursor/skills/` (mesmo conteúdo que `.claude/skills/`). No Agent, use `@task-flow-run`, `@task-flow-sync`, etc.
+O `rbin-task-flow init` copia **11 skills** para `.cursor/skills/` (mesmo conteúdo que `.claude/skills/`). No Agent, use `@task-flow-split`, `@task-flow-run`, `@task-flow-sync`, etc.
 
 Após `rbin-task-flow init` ou `update`, use `@task-flow-*` no Agent. Para sync: `@task-flow-sync` (não `task_generation` isolado).
 
@@ -281,7 +282,7 @@ Para open source: documente no README — contribuidores podem usar `--share-ai-
 ## 13. Checklist de maturidade Cursor + Task Flow
 
 - [x] `task-flow-cursor.mdc` + `rbin-git-policy.mdc` (2 always-on, v1.23)
-- [x] 10 skills em `.cursor/skills/` após `init`
+- [x] 11 skills em `.cursor/skills/` após `init`
 - [x] Otimização P0 de tokens (ver §3)
 - [ ] `task-flow: sync` após cada edição em `tasks.input.txt`
 - [ ] `@task-flow-run` (não `@task_work`) para implementar

package/AGENTS.md

@@ -31,6 +31,7 @@ No explanatory comments. Complex topics → `dev-logs/*.md`. Allowed: `// ──
 | `task-flow: sync` | Section **Sync** below; details `.task-flow/guides/CODEX.md` |
 | `task-flow: from contexts` | `.cursor/rules/task_from_contexts.mdc` · then `sync` |
 | `task-flow: run …` | Section **Run** below; details `.task-flow/guides/CODEX.md` |
+| `task-flow: split:N` | `.cursor/rules/task_split.mdc` · N obrigatório (`split:3`, `split:2 50-72`) |
 | `task-flow: status` | `.task-flow/tasks.status.md` |
 | `task-flow: audit` | `.cursor/rules/task_audit.mdc` · checklist `coding_standards.mdc` (full: `.task-flow/guides/coding-standards-full.md` if needed) |
 | `task-flow: validate` | `.cursor/rules/task_validate.mdc` · then sync |

package/CLAUDE.md

@@ -16,6 +16,7 @@
 | Sync input → system | `/task-flow-sync` |
 | Draft tasks from `contexts/` | `/task-flow-from-contexts` |
 | Run subtasks | `/task-flow-run` |
+| Split pending for N IAs (`split:3`, `split:2`, …) | `/task-flow-split` |
 | Status | `/task-flow-status` |
 | Audit repo | `/task-flow-audit` |
 | Validate + fill gaps | `/task-flow-validate` |

package/README.md

@@ -93,13 +93,13 @@ Após inicializar, use estes comandos na IA (Cursor/Claude/Codex) para gerenciar
 
 **Graphify (opcional):** grafo em `.task-flow/guides/graphify-out/`. Novo projeto: `rbin-task-flow init --graphify`. **Já tem Task Flow:** `npm install -g rbin-task-flow@latest` e `rbin-task-flow update --graphify` no projeto (migra `graphify-out/` da raiz + regera grafo). Detalhes: [.task-flow/README.md](.task-flow/README.md#graphify-opcional) · [GRAPHIFY.md](.task-flow/guides/GRAPHIFY.md).
 
-**Claude Code / Cursor skills (v1.20+):** `init` copia 10 skills para `.claude/skills/` e `.cursor/skills/` — use `/task-flow-from-contexts`, `/task-flow-sync`, `/task-flow-run`, etc.
+**Claude Code / Cursor skills (v1.20+):** `init` copia 11 skills para `.claude/skills/` e `.cursor/skills/` — use `/task-flow-split`, `/task-flow-sync`, `/task-flow-run`, etc.
 
 **Codex (v1.21+):** `AGENTS.md` com sync/run embutidos, `.task-flow/guides/CODEX.md` sob demanda, `.codex/config.toml` (64 KiB).
 
 **Cursor (v1.23+):** `task-flow-cursor.mdc` + `rbin-git-policy.mdc` (2 always-on) + skills — ver `.task-flow/guides/CURSOR.md`.
 
-**Perfil minimal:** `init --profile minimal` instala só as 2 regras always-on e as 10 skills; workflows via `@task-flow-*` (sem `task_work`, `coding_standards` glob, etc.). `standard` (padrão) copia todas as regras `.cursor/rules/`.
+**Perfil minimal:** `init --profile minimal` instala só as 2 regras always-on e as 11 skills; workflows via `@task-flow-*` (sem `task_work`, `coding_standards` glob, etc.). `standard` (padrão) copia todas as regras `.cursor/rules/`.
 
 **Compartilhar com o time:** `init --share-ai-config` não ignora `.cursor/skills/` nem `.cursor/rules/` no `.gitignore` (só `.cursor/settings.json` e overrides locais). Padrão: `.cursor/` inteiro ignorado — menos ruído no repo, config local por dev.
 
@@ -109,6 +109,7 @@ Após inicializar, use estes comandos na IA (Cursor/Claude/Codex) para gerenciar
 | `task-flow: sync` | **Sincroniza** tarefas do arquivo texto com o sistema | Mantém tudo sincronizado automaticamente - adiciona novas, remove deletadas, preserva seu progresso |
 | `task-flow: audit` | **Avalia** o quanto o código bate com os padrões de codificação | Analisa a codebase, dá um score por categoria e pergunta quais melhorias você quer adotar — sem impor nada |
 | `task-flow: status` | **Visualiza** o progresso rapidamente | Vê resumo com tasks completas, em andamento e quantas subtarefas faltam |
+| `task-flow: split` | `:3` · `:2` · `:3 50-72` | **Divide** trabalho entre N IAs — gera N comandos `run X,Y,Z` (só plano) |
 | `task-flow: run next X` | **Automatiza** o trabalho nas próximas subtarefas | A IA trabalha nas próximas X subtarefas sequencialmente, você só acompanha |
 | `task-flow: run X` | **Completa** uma tarefa inteira de uma vez | Executa todas as subtarefas de uma tarefa específica (permite trabalho paralelo) |
 | `task-flow: run X,Y` | **Completa** múltiplas tarefas | Executa tarefas separadas por vírgula (ex: `task-flow: run 10,11`) |
@@ -475,11 +476,11 @@ After initializing, use these commands in your AI (Cursor/Claude/Codex) to autom
 
 **Graphify (optional):** graph at `.task-flow/guides/graphify-out/`. New project: `rbin-task-flow init --graphify`. **Existing project:** `npm install -g rbin-task-flow@latest` then `rbin-task-flow update --graphify` (migrates legacy root `graphify-out/` + re-extracts). See [.task-flow/README.md](.task-flow/README.md#graphify-opcional) · [GRAPHIFY.md](.task-flow/guides/GRAPHIFY.md).
 
-**Claude / Cursor skills (v1.20+):** installs 10 skills — use `/task-flow-from-contexts`, `/task-flow-sync`, `/task-flow-run`, etc.
+**Claude / Cursor skills (v1.20+):** installs 11 skills — use `/task-flow-split`, `/task-flow-sync`, `/task-flow-run`, etc.
 
 **Codex (v1.21+):** optimized `AGENTS.md`, `.task-flow/guides/CODEX.md`, `.codex/config.toml`.
 
-**Cursor (v1.23+):** 2 always-on rules + 10 skills — `@task-flow-from-contexts`, `@task-flow-sync`, `@task-flow-run`.
+**Cursor (v1.23+):** 2 always-on rules + 11 skills — `@task-flow-split`, `@task-flow-sync`, `@task-flow-run`.
 
 **Minimal profile:** `init --profile minimal` copies only `task-flow-cursor.mdc` and `rbin-git-policy.mdc` plus skills; use `@task-flow-*` for workflows. `standard` (default) copies all rules under `.cursor/rules/`.
 
@@ -491,6 +492,7 @@ After initializing, use these commands in your AI (Cursor/Claude/Codex) to autom
 | `task-flow: sync` | **Sync** tasks from text file with system | Keeps everything synchronized automatically - adds new, removes deleted, preserves your progress |
 | `task-flow: audit` | **Evaluate** how well your code matches coding standards | Scans the codebase, scores it by category and asks which improvements you want to adopt — never imposes changes |
 | `task-flow: status` | **Visualize** progress quickly | See summary with completed tasks, in progress, and remaining subtasks |
+| `task-flow: split` | `:3` · `:2` · `:3 50-72` | **Split** work across N AIs — N `run` commands (plan only) |
 | `task-flow: run next X` | **Automate** work on next subtasks | AI works on next X subtasks sequentially, you just follow along |
 | `task-flow: run X` | **Complete** an entire task at once | Executes all subtasks of a specific task (allows parallel work) |
 | `task-flow: run X,Y` | **Complete** multiple tasks | Executes comma-separated tasks (e.g., `task-flow: run 10,11`) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbin-task-flow",
-  "version": "1.26.1",
+  "version": "1.27.1",
   "description": "AI-powered task management for Claude and Cursor",
   "main": "index.js",
   "bin": {