rbin-task-flow 1.26.1 → 1.30.1

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

@@ -7,9 +7,11 @@ paths: [".task-flow/**"]
 
 # Task Flow — Report
 
-1. Verify task X is fully `done` in `status.json` (warn if partial).
+1. Verify task X is fully `done` in `status.json` — **no** `manual`, `pending`, or `in_progress` subtasks (warn and stop if any).
 2. Read `tasks.json`; analyze related code changes (read-only git ok).
 3. Write `.task-flow/guides/reports/task-X-implementation.md` using project template.
 4. Create `.task-flow/guides/reports/` if missing.
 
+**Never** generate this report during `task-flow: run` — only when the user explicitly asks for `task-flow: report`.
+
 Reference: `.cursor/rules/task_report.mdc`

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

@@ -13,15 +13,21 @@ paths: [".task-flow/**"]
 
 ## Steps
 
-1. Read `status.json` first; list **pending** task/subtask IDs only.
-2. **tasks.json (token discipline):** Count subtasks across all tasks. If **>50**, do **not** load the full file — read only the JSON slice for each active task id (pending subtasks you will run). If ≤50, full read is OK.
-3. Parse intent: `run next X` (default X=1) | `run X` | `run X,Y` | `run all`.
-4. **`run X` / `run X,Y`:** If any task before X has pending subtasks, **stop** and list blocking tasks.
-5. For each subtask: follow `instructions`; read `.task-flow/contexts/` files when referenced.
-6. If `.task-flow/guides/graphify-out/graph.json` exists, prefer `graphify query "<module from subtask>" --graph .task-flow/guides/graphify-out/graph.json` before broad grep (summarized output only — see GRAPHIFY.md).
-7. After each subtask: update `status.json` and `tasks.status.md` (regenerate 📊 Summary).
-8. When parent task complete: mark task `done` in both files.
-9. Invoke `/rbin-git` logic to **suggest** commit only — never `git add`/`commit`/`push`.
+1. Read `status.json`; resolve **`manual`** subtasks first via dev-logs + current conversation (see workflow).
+2. List **pending** task/subtask IDs (`done`, `manual` until resolved).
+3. **tasks.json:** partial read by task id if **>50** subtasks total.
+4. Parse intent: `run next X` (default X=1) | `run X` | `run X,Y` | `run all`.
+5. **`run X` / `run X,Y`:** Stop if earlier tasks/subtasks are not `done`.
+6. Per subtask: `instructions` + `contexts/`; optional `graphify query`.
+7. **Automatable** → `done` + `tasks.status.md` Summary.
+8. **Manual intervention** → `manual` + `.task-flow/dev-logs/task-X.Y-manual.md`; user reports progress **in chat**; AI appends **Conversation log** and marks `done` only when verified complete.
+9. Parent task all `done` → mark task `done`.
+10. Suggest commit via `/rbin-git` — never git write.
+
+## Never during run
+
+- Mark `done` when manual steps remain unverified
+- Write `guides/reports/task-*-implementation.md`
 
 ## Full workflow
 

package/.claude/skills/task-flow-run/workflow.md

@@ -4,56 +4,116 @@
 
 | Input | Behavior |
 |-------|----------|
-| `task-flow: run next X` | Next X pending subtasks in order (task 1.1, 1.2, …, 2.1, …) |
+| `task-flow: run next X` | Next X **pending** subtasks in order (skip `done`; resolve `manual` first — see below) |
 | `task-flow: run next` | X = 1 |
-| `task-flow: run X` | All pending subtasks of task X |
+| `task-flow: run X` | All **pending** subtasks of task X |
 | `task-flow: run X,Y` | Tasks X then Y sequentially |
-| `task-flow: run all` | All pending subtasks |
+| `task-flow: run all` | All **pending** subtasks |
+
+Subtasks in `manual` block later subtasks in the same task until the dev-log shows they are complete.
+
+## Before picking pending subtasks — resolve `manual`
+
+1. List all `manual` subtasks in scope (same task or global for `run next`).
+2. Read `.task-flow/dev-logs/task-X.Y-manual.md` for each.
+3. Use the **current conversation** (and codebase checks) to assess completion — no separate confirm command.
+4. If the user reported progress in chat, append to the dev-log **Conversation log** (see format below).
+5. When the log + verification show all manual steps done → set `done`, refresh `tasks.status.md`, continue the run.
+6. If still incomplete → keep `manual`, tell the user what remains; do not skip marking done prematurely.
 
 ## Dependency check (`run X`)
 
 1. For tasks `1 .. X-1`, verify every subtask is `done`.
-2. If any pending: stop with  
-   `⚠️ Cannot execute task X: complete tasks [list] first. Use task-flow: run Y.`
-3. Do not execute any subtask of X until cleared.
+2. If any `pending`, `manual`, or `in_progress`: stop with  
+   `⚠️ Cannot execute task X: complete tasks [list] first. Use task-flow: run Y or finish manual steps in dev-logs.`
+3. For task X: if any earlier subtask is still `manual` (dev-log incomplete), stop — resolve via conversation first.
 
 ## tasks.json — partial read (>50 subtasks)
 
-1. From `status.json`, collect pending `(taskId, subtaskId)` for this run.
-2. Count total subtasks in `tasks.json` (quick parse or `jq '[.tasks[].subtasks | length] | add'`).
-3. If total **>50**: load **only** each `tasks[]` entry where `id` is in the pending set — not the full array.
-4. If **≤50**: loading the full `tasks.json` is acceptable.
-
-## Per subtask
-
-1. Load subtask from `tasks.json` (title, description, instructions) — slice for that task id only when using partial read.
-2. If instructions cite `.task-flow/contexts/...`, read those files.
-3. Implement; verify (tests/build as appropriate).
-4. Set subtask to `done` in `status.json`.
-5. Update `tasks.status.md`: `- [x]` on subtask; regenerate Summary (✅ / ⏳ / 📝 counts).
-6. If blocked: set `in_progress` and explain.
-
-## status.json shape
-
-```json
-{
-  "tasks": {
-    "1": {
-      "status": "pending",
-      "subtasks": { "1": "done", "2": "pending" }
-    }
-  }
-}
+1. From `status.json`, collect **pending** `(taskId, subtaskId)` for this run.
+2. Count total subtasks in `tasks.json`.
+3. If total **>50**: load only each `tasks[]` entry for pending/manual task ids.
+4. If **≤50**: full read is OK.
+
+## Per subtask — fully automatable
+
+1. Load subtask from `tasks.json`.
+2. Read `.task-flow/contexts/` when cited.
+3. Implement; verify (tests/build).
+4. `done` in `status.json` + update `tasks.status.md` Summary.
+5. Suggest commit via `@rbin-git` when appropriate.
+
+## Per subtask — manual intervention required
+
+When the agent **cannot** finish alone (deploy, console, credentials, production, third-party dashboard, etc.):
+
+1. Implement everything possible in code/repo first.
+2. Set **`manual`** in `status.json` — never `done`.
+3. Create `.task-flow/dev-logs/task-X.Y-manual.md`:
+
+```markdown
+# Task X.Y — Manual intervention required
+
+**Subtask:** [title]
+**Status:** manual
+**Created:** [ISO 8601]
+
+## What the AI completed
+- [automated work]
+
+## What you need to do manually
+1. [clear step]
+2. [clear step]
+
+## Conversation log
+(AI appends as you report progress in chat — no separate command)
+
+### YYYY-MM-DDTHH:mm:ssZ
+**User said:** [from conversation]
+**Verified:** pending | complete
+**Notes:** [what was checked; what remains]
 ```
 
+4. `tasks.status.md`: `- [~] [title] — manual: .task-flow/dev-logs/task-X.Y-manual.md`
+5. Stop further subtasks in that task.
+6. Tell the user the manual steps; they report back **in normal chat** when done.
+
+## Conversation-driven completion (any turn)
+
+Applies during `run`, `status`, or whenever the user mentions manual work — **no `task-flow: confirm` command**.
+
+1. Read `status.json` for `manual` subtasks.
+2. Match user message to a dev-log (by task id, keywords, or open manual items).
+3. Append **Conversation log** entry with what the user said.
+4. Verify against checklist + codebase when possible.
+5. All steps satisfied → `done` + `tasks.status.md` + continue blocked work on next `run`.
+6. Partial → keep `manual`, update dev-log with remaining steps.
+
+## Never during run
+
+- Mark `done` when manual steps remain unverified
+- Write `.task-flow/guides/reports/task-*-implementation.md` (`task-flow: report` only)
+
+## Blocked (not manual)
+
+Temporarily blocked without user action: `in_progress` + explain.
+
+## status.json
+
+Subtask status: `pending` | `done` | `in_progress` | `manual`
+
 ## Completion summary
 
 ```
 ✅ Completed N subtasks:
 - Task 1.2: [title]
-📝 Next pending: Task 1.3
+
+🖐️ Manual — waiting on you:
+- Task 1.3: .task-flow/dev-logs/task-1.3-manual.md (report in chat when done)
+
+📝 Next pending: Task 1.4 (after 1.3 resolves)
 ```
 
-## Related rules
+## Related
 
-Cursor fallback (short): `.cursor/rules/task_work.mdc` — prefer `@task-flow-run` / this file.
+Cursor fallback: `.cursor/rules/task_work.mdc` — prefer `@task-flow-run` / this file.

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/.claude/skills/task-flow-status/SKILL.md

@@ -7,7 +7,7 @@ disable-model-invocation: false
 # Task Flow — Status
 
 1. Read `.task-flow/tasks.status.md`.
-2. Display summary (✅ completed, ⏳ in progress, 📝 remaining) and task/subtask checkboxes.
+2. Display summary (✅ completed, ⏳ in progress, 🖐️ manual, 📝 remaining) and task/subtask checkboxes (`[x]` `[ ]` `[~]`).
 3. If file missing, suggest `/task-flow-sync`.
 
 Reference: `.cursor/rules/task_status.mdc`

package/.claude/skills/task-flow-sync/workflow.md

@@ -43,12 +43,12 @@ All subtasks `pending`; task `pending`.
 ## tasks.status.md
 
 - Auto-generated banner warning (do not edit manually).
-- Summary section with counts.
-- `- [ ]` / `- [x]` for tasks and indented subtasks.
+- Summary section with counts (include 🖐️ manual when any).
+- `- [ ]` / `- [x]` / `- [~]` for tasks and indented subtasks (`[~]` → link dev-log).
 
 ## Sync-only rules
 
-- Preserve status on modified tasks when subtasks still match.
+- Preserve status on modified tasks when subtasks still match (`done`, `manual`, `pending`).
 - New subtasks after regen → `pending`; removed subtasks → drop from status.
 - Never explore codebase during pure sync unless user explicitly asks for codebase analysis in the same message.
 

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

@@ -14,6 +14,7 @@ alwaysApply: true
 | `.task-flow/.internal/tasks.json` | Definitions |
 | `.task-flow/.internal/status.json` | Status source of truth |
 | `.task-flow/contexts/` | Specs / mockups |
+| `.task-flow/dev-logs/` | Manual steps + conversation log (`task-X.Y-manual.md`) |
 | `.task-flow/guides/` | Platform guides, Graphify, standards, reports |
 
 ## Prefer skills (`.cursor/skills/`)
@@ -23,6 +24,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` |
@@ -33,6 +35,8 @@ alwaysApply: true
 
 Natural language (`work on next 3 subtasks`) = same as `task-flow: run next 3`.
 
+**Manual subtasks:** user reports progress in chat; AI updates `.task-flow/dev-logs/` Conversation log and marks `done` when verified — no separate command.
+
 ## Git (always)
 
 Never write git — user runs all commits. Policy: [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc). Suggest via `@rbin-git`.

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

@@ -20,7 +20,7 @@ alwaysApply: false
 |--------|--------|
 | **New** | Generate task + 3–8 subtasks; all `pending` |
 | **Removed** | Drop from `tasks.json`, `status.json`, `tasks.status.md` |
-| **Modified** | Update title/description; regen subtasks; **preserve** done/pending status where possible |
+| **Modified** | Update title/description; regen subtasks; **preserve** done/pending/**manual** status where possible |
 | **Unchanged** | Leave task data and status as-is |
 
 Task IDs stay sequential (1, 2, 3…) matching `tasks.input.txt` order.
@@ -38,8 +38,8 @@ Task IDs stay sequential (1, 2, 3…) matching `tasks.input.txt` order.
 ## 4. Align status
 
 - `status.json` = source of truth
-- Rebuild `tasks.status.md` checkboxes to match; **regenerate 📊 Summary** (completed / in progress / remaining counts)
-- After regen: new subtasks → `pending`; keep `done` on matched subtasks when possible
+- Rebuild `tasks.status.md` checkboxes to match (`[ ]` pending · `[x]` done · `[~]` manual); **regenerate 📊 Summary** (completed / in progress / 🖐️ manual / remaining counts)
+- After regen: new subtasks → `pending`; keep `done` and `manual` on matched subtasks when possible
 
 ## 5. Principles
 

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_generation.mdc

@@ -26,9 +26,9 @@ Use this rule for **subtask shape** when `task-flow-sync` creates or regenerates
 
 **tasks.json:** `id`, `title`, `description`, `originalRequest`, `createdAt`, `subtasks[]` with `id`, `title`, `description`, `instructions`.
 
-**status.json:** `tasks.{id}.status`, `tasks.{id}.subtasks.{subtaskId}` → `pending` | `done` | `in_progress`.
+**status.json:** `tasks.{id}.status`, `tasks.{id}.subtasks.{subtaskId}` → `pending` | `done` | `in_progress` | `manual`.
 
-**tasks.status.md:** banner “do not edit”; 📊 Summary; tasks `- [ ]`/`- [x]`; subtasks indented with two spaces.
+**tasks.status.md:** banner “do not edit”; 📊 Summary (include 🖐️ manual count); `- [ ]` pending · `- [x]` done · `- [~]` manual (link to `.task-flow/dev-logs/task-X.Y-manual.md`).
 
 ## Rules
 

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/.cursor/rules/task_status.mdc

@@ -9,11 +9,11 @@ alwaysApply: false
   - When user says "task-flow: status" or "task-flow status":
     - **READ**: `.task-flow/tasks.status.md`
     - **DISPLAY**: Show the current status of all tasks and subtasks
-    - **FORMAT**: Display in a clear, readable format showing done/pending tasks
+    - **FORMAT**: Display done `[x]`, pending `[ ]`, manual `[~]` (see `.task-flow/dev-logs/`)
 
 - **Status Display:**
   - Read `.task-flow/tasks.status.md` file
-  - Show tasks marked as `- [x]` (done) and `- [ ]` (pending)
+  - Show tasks marked as `- [x]` (done), `- [ ]` (pending), `- [~]` (manual — user action required)
   - Display subtasks with their status
   - Show progress summary if available
 

package/.cursor/rules/task_validate.mdc

@@ -32,12 +32,13 @@ For each task/subtask in scope:
 | Status | Check |
 |--------|--------|
 | `done` | Implementation exists and matches requirements (files, tests, docs per instructions) |
+| `manual` | Dev-log + conversation log; not `done` until IA verifies via chat history |
 | `pending` / `in_progress` | Whether code already partially or fully implements the subtask (status drift) |
 
 Record:
 
 - **Verified done** — correctly marked
-- **False done** — marked `done` but missing or incomplete
+- **False done** — marked `done` but missing, incomplete, or should be `manual`
 - **Drift** — implemented in code but still `pending`
 - **Confirmed pending** — not implemented yet (expected)
 
@@ -51,7 +52,7 @@ Find work not covered by current tasks:
 
 ### 4. Apply fixes (no ask — user invoked validate)
 
-1. **Status:** set false `done` → `pending` in `status.json`; optional drift `pending` → keep or note in report (do not auto-mark `done` without user run)
+1. **Status:** set false `done` → `pending` or `manual` (with dev-log if user action required) in `status.json`
 2. **Input:** append new lacunas as `- Description` lines to `tasks.input.txt` (append only; never remove or edit existing lines)
 3. **Sync:** follow [task-flow-sync.mdc](mdc:.cursor/rules/task-flow-sync.mdc) — diff input, regen subtasks for new tasks, rebuild `tasks.status.md` Summary
 4. **Never** edit `.internal/` by hand except through sync-aligned updates to `status.json` for false-done fixes before sync

package/.cursor/rules/task_work.mdc

@@ -5,32 +5,14 @@ alwaysApply: false
 
 # Task Flow — Run (fallback)
 
-**Prefer:** `@task-flow-run` (Claude: `/task-flow-run`) — full steps in `.claude/skills/task-flow-run/workflow.md` (same under `.cursor/skills/` after install).
+**Prefer:** `@task-flow-run` — `.claude/skills/task-flow-run/workflow.md`
 
-**Task flow** = RBIN Task Flow. Do not edit `.task-flow/.internal/` by hand.
+## Critical flow
 
-## Commands
+1. **Resolve `manual` first:** read dev-logs + conversation; append Conversation log; mark `done` only when verified.
+2. **`run next X`:** pending subtasks only; `manual` blocks until dev-log shows complete.
+3. **Automatable** → `done`; **user must act** → `manual` + dev-log; never `done` until log confirms.
+4. User reports manual progress **in normal chat** — no separate confirm command.
+5. Suggest commit via `@rbin-git` — never write git.
 
-| User says | Action |
-|-----------|--------|
-| `task-flow: run next X` / `run next` | Next X pending subtasks in order (default X=1) |
-| `task-flow: run X` | All pending subtasks of task X |
-| `task-flow: run X,Y` / `run all` | As labeled |
-
-Natural language (`work on next 3 subtasks`, `execute all subtasks of task 2`) = same as above.
-
-## Critical flow (each subtask)
-
-1. Read `status.json` first; load `tasks.json` by pending task ids only if **>50 subtasks** total (see `@task-flow-run` workflow).
-2. **`run X`:** If tasks `1..X-1` have any pending subtask, **stop** and list blockers; do not run X.
-3. Implement per `instructions`; read `.task-flow/contexts/` when referenced; optional `graphify query` if `.task-flow/guides/graphify-out/` exists ([graphify-task-flow.mdc](mdc:.cursor/rules/graphify-task-flow.mdc)).
-4. After each subtask: `status.json` → `done`; `tasks.status.md` → `- [x]` + regenerate 📊 Summary.
-5. Parent task all done → mark task `done` in both files.
-6. Suggest commit via [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc) / `@rbin-git` — never write git.
-
-If blocked: subtask `in_progress` + explain.
-
-## More detail
-
-- Skill workflow: `.claude/skills/task-flow-run/workflow.md`
-- Command index: [task-flow-cursor.mdc](mdc:.cursor/rules/task-flow-cursor.mdc) · [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) (stub)
+**Never during run:** `guides/reports/task-*-implementation.md`.

package/.task-flow/README.md

@@ -8,6 +8,7 @@
 ├── tasks.input.txt        ← defina tasks (`- descrição`)
 ├── tasks.status.md        ← progresso (auto; não editar)
 ├── contexts/              ← specs, mockups
+├── dev-logs/              ← passos manuais + log da conversa (IA atualiza)
 ├── .internal/             ← tasks.json, status.json (sistema)
 └── guides/                ← documentação e configs
     ├── AI-PLATFORMS.md
@@ -46,15 +47,23 @@ cd seu-projeto
 rbin-task-flow init --graphify
 ```
 
-### Projeto que já usa Task Flow (atualizar pacote + migrar grafo)
+### Projeto que já usa Task Flow (subir versão + migrar grafo)
 
 ```bash
 npm install -g rbin-task-flow@latest
 cd seu-projeto
-rbin-task-flow update --graphify
+rbin-task-flow reset --keep-tasks --graphify
 ```
 
-O `update --graphify` reaplica rules/skills, move `graphify-out/` legado da raiz para `guides/graphify-out/` (se existir) e roda o extract.
+**Manter suas tasks** ao subir versão (não sobrescreve `tasks.input.txt`, `tasks.status.md` nem `.internal/`):
+
+```bash
+npm install -g rbin-task-flow@latest
+cd seu-projeto
+rbin-task-flow reset --keep-tasks
+```
+
+O `reset --keep-tasks --graphify` reaplica rules/skills, move `graphify-out/` legado da raiz para `guides/graphify-out/` (se existir) e roda o extract.
 
 ### Só regerar o grafo (sem reinstall do template)
 
@@ -80,7 +89,8 @@ Guia completo: [guides/GRAPHIFY.md](guides/GRAPHIFY.md).
 | `task-flow: sync` | — | Complete synchronization: adds new, removes deleted, updates modified, preserves status |
 | `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: run` | `next X` · `X` · `X,Y` · `all` | Execute pending subtasks; manual → `dev-logs/`, status `manual` |
+| `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 |
@@ -110,7 +120,7 @@ Complete synchronization between `tasks.input.txt` and the system:
 - ✅ Adds new tasks from `tasks.input.txt`
 - ✅ Removes tasks that were deleted from `tasks.input.txt`
 - ✅ Updates tasks that were modified in `tasks.input.txt`
-- ✅ Preserves status (done/pending) of existing tasks
+- ✅ Preserves status (`done`, `pending`, `manual`) of existing tasks
 - ✅ Synchronizes status between `status.json` and `tasks.status.md` (ensures they are always aligned)
 
 ### `task-flow: validate`
@@ -126,15 +136,28 @@ 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".
+Works on next X **pending** subtasks. Resolves `manual` first by reading dev-logs and the current conversation.
+
+- **Fully automatable** → `done`
+- **Needs your action** → `manual` + `.task-flow/dev-logs/task-X.Y-manual.md`
+- You report progress **in chat** (no extra command); the AI appends the **Conversation log** and marks `done` when verified
 
 **Examples:**
-- `task-flow: run next 4` → Next 4 subtasks
-- `task-flow: run next` → Next 1 subtask
+- `task-flow: run next 4` → Next 4 pending subtasks
+- `task-flow: run next` → Next 1 pending subtask
 
 ### `task-flow: run X` (simplified syntax)
-Executes all pending subtasks of a specific task. Implements and marks as "done".
+Executes all **pending** subtasks of a specific task. Stops if a subtask requires manual intervention.
 
 **⚠️ Dependency Check:**
 - Only executes if all previous tasks (1, 2, ..., X-1) are completely finished

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).
 
@@ -52,10 +53,10 @@ Detalhes dos comandos: [README.md](../README.md).
 | `.task-flow/guides/CURSOR.md` | — | ✅ | — |
 | `.task-flow/guides/coding-standards-full.md` | on demand | on demand (sections only) | on demand |
 | [OPTIMIZATION-PLAN.md](OPTIMIZATION-PLAN.md) | — | token roadmap | — |
-| `.codex/config.toml` | — | — | ✅ (opcional, preservado no update) |
+| `.codex/config.toml` | — | — | ✅ (opcional, preservado no reset --keep-tasks) |
 | `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.