rbin-task-flow 1.27.1 → 1.30.3

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-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/`)
@@ -34,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_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_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,7 @@ 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` |
@@ -111,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`
@@ -137,14 +146,18 @@ Plans **parallel work across N IAs** (`split:3`, `split:2`, …). **`:N` is requ
 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

@@ -53,13 +53,13 @@ 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/` | ✅ (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.
+Por padrão, **`.task-flow`** é acrescentado ao final do **`.gitignore`** do projeto cliente.
 
 ---
 

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

@@ -46,11 +46,13 @@ Rule: `.cursor/rules/task_split.mdc`
 
 See AGENTS.md **Run** section. Prefer `.claude/skills/task-flow-run/workflow.md`; fallback: `.cursor/rules/task_work.mdc`.
 
-**Dependency:** `run N` only if tasks `1..N-1` fully done.
+**Dependency:** `run N` only if tasks `1..N-1` fully `done` (no `manual` blocking).
 
-**Per subtask:** implement → `done` in `status.json` → refresh `tasks.status.md` → suggest commit.
+**Per subtask (automatable):** implement → `done` → refresh `tasks.status.md` → suggest commit.
 
-**Blocked:** set `in_progress`, explain.
+**Manual intervention:** implement what you can → `manual` → dev-log → user reports in chat → AI updates Conversation log → `done` when verified.
+
+**Never during run:** `guides/reports/task-*-implementation.md`.
 
 ---
 

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

@@ -13,7 +13,7 @@ Verify: `rg 'alwaysApply: true' .cursor/rules` → only the two files above.
 
 **Install profiles:** `rbin-task-flow init --profile minimal` → 2 always-on rules + skills only; `standard` (default) → all `.mdc` rules. Saved in `.task-flow/install-meta.json`.
 
-**Team git:** `init --share-ai-config` → `.cursor/skills/` and `.cursor/rules/` not gitignored (default ignores all `.cursor/`).
+**Team git:** `.task-flow` appended to `.gitignore`; other AI config files can be committed.
 
 ---
 
@@ -78,12 +78,12 @@ Only during `run` / `validate` when `.task-flow/guides/graphify-out/` exists. Do
 
 | Issue | Fix |
 |-------|-----|
-| Ignores task-flow | `rbin-task-flow update` |
+| Ignores task-flow | `rbin-task-flow reset --keep-tasks` |
 | Run workflow wrong | **`@task-flow-run`** — avoid `@task_work` |
 | Rule not applied | `@task-flow-<command>` for that workflow |
 | Standards missing | File under `src/` or `@rbin-coding-standards` |
 | Context too large | Fewer `src/` files in chat; skills not full docs |
-| Wrong always-on count | `update`; don't set `graphify.mdc` always-on |
+| Wrong always-on count | `reset --keep-tasks`; don't set `graphify.mdc` always-on |
 
 ---
 

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

@@ -31,7 +31,7 @@ Graphify ([graphifyy](https://pypi.org/project/graphifyyy/)) cria um **grafo de
 1. Copia **`.cursor/rules/graphify-task-flow.mdc`** — `alwaysApply: false` (não compete com `task_work`, etc.).
 2. Grafo em **`.task-flow/guides/graphify-out/`** (já coberto pelo `.task-flow/` no `.gitignore`; remove entrada legada `graphify-out/` na raiz).
 3. Se existir **`.cursor/rules/graphify.mdc`** do `graphify cursor install` (upstream com `alwaysApply: true`), o instalador **desativa** `alwaysApply` para economizar contexto.
-4. Com **`--graphify`** em `init`, `update` ou **`reset`**, roda `graphify extract . --backend claude-cli --out .task-flow/guides` se o CLI estiver no PATH (usa assinatura Claude Code — sem API key separada).
+4. Com **`--graphify`** em `init` ou **`reset`**, roda `graphify extract . --backend claude-cli --out .task-flow/guides` se o CLI estiver no PATH (usa assinatura Claude Code — sem API key separada).
 
 **Não** rodamos `graphify claude install` / `graphify cursor install` automaticamente — o install upstream força `graphify.mdc` always-on e incham `CLAUDE.md` / `AGENTS.md`.
 
@@ -41,7 +41,7 @@ Graphify ([graphifyy](https://pypi.org/project/graphifyyy/)) cria um **grafo de
 
 ```bash
 cd seu-projeto
-rbin-task-flow reset --graphify   # ou init/update --graphify; recria .task-flow + grafo
+rbin-task-flow reset --keep-tasks --graphify   # ou init --graphify; recria template + grafo
 task-flow: sync
 task-flow: run next 3             # IA usa grafo só ao implementar
 # você: git commit
@@ -89,7 +89,7 @@ task-flow: run next 2 — se .task-flow/guides/graphify-out/ existir, graphify q
 | Primeiro setup | `rbin-task-flow init --graphify` ou `graphify extract . --backend claude-cli --out .task-flow/guides` |
 | Reset completo (tasks + template + grafo) | `rbin-task-flow reset --graphify` |
 | Refactor grande após vários `run` | `graphify update .` ou `graphify extract . --backend claude-cli --out .task-flow/guides` |
-| `task-flow: update` | Reaplica `graphify-task-flow.mdc` e pode rebaixar `graphify.mdc` |
+| `rbin-task-flow reset --keep-tasks` | Reaplica `graphify-task-flow.mdc` e pode rebaixar `graphify.mdc` |
 
 ---
 

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

@@ -36,7 +36,7 @@ projeto/
 └── .task-flow/
 ```
 
-Após `rbin-task-flow init` ou `update`, use **`/task-flow-sync`**, **`/task-flow-run`**, etc. Reinicie o Claude Code se `.claude/skills/` foi criado pela primeira vez na sessão.
+Após `rbin-task-flow init` ou `reset --keep-tasks`, use **`/task-flow-sync`**, **`/task-flow-run`**, etc. Reinicie o Claude Code se `.claude/skills/` foi criado pela primeira vez na sessão.
 
 ---
 

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

@@ -33,8 +33,8 @@ Documentação: [Cursor Rules](https://cursor.com/docs/context/rules) · Referê
 | **minimal** | `rbin-task-flow init --profile minimal` | Só `task-flow-cursor.mdc` + `rbin-git-policy.mdc` + skills |
 
 - **minimal:** ≤2 always-on; workflows só via `@task-flow-*` (sem glob `coding_standards`, `task_work`, etc.).
-- **update** sem `--profile` reaplica o profile salvo em `.task-flow/install-meta.json`.
-- Migrar para regras completas: `rbin-task-flow update --profile standard`.
+- **reset** sem `--profile` reaplica o profile salvo em `.task-flow/install-meta.json`.
+- Migrar para regras completas: `rbin-task-flow reset --profile standard --keep-tasks`.
 
 ---
 
@@ -111,7 +111,7 @@ Cursor suporta o mesmo formato que Claude Code: `.cursor/skills/<nome>/SKILL.md`
 
 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).
+Após `rbin-task-flow init` ou `reset --keep-tasks`, use `@task-flow-*` no Agent. Para sync: `@task-flow-sync` (não `task_generation` isolado).
 
 ---
 
@@ -201,7 +201,7 @@ Coloque PNG/PDF/MD em `.task-flow/contexts/`. Nas subtarefas geradas, instruçõ
 | Stubs `task_work` / `task_execution` | ✅ |
 | Unificar git em `rbin-git-policy` | ✅ |
 
-**No seu projeto:** `rbin-task-flow update` reaplica o template. Evite reativar `alwaysApply: true` em `graphify.mdc` upstream.
+**No seu projeto:** `rbin-task-flow reset --keep-tasks` reaplica o template. Evite reativar `alwaysApply: true` em `graphify.mdc` upstream.
 
 **Roadmap:** [OPTIMIZATION-PLAN.md](../OPTIMIZATION-PLAN.md) · tarefas: [OPTIMIZATION-IMPLEMENTATION-TASKS.md](../OPTIMIZATION-IMPLEMENTATION-TASKS.md).
 
@@ -238,29 +238,19 @@ Cursor também pode ler `AGENTS.md` em alguns fluxos; no RBIN ele é focado em *
 
 | Comando CLI | Uso com Cursor |
 |-------------|----------------|
-| `rbin-task-flow init` | Copia rules + task-flow |
-| `rbin-task-flow update` | Atualiza rules; preserva `.internal/` |
+| `rbin-task-flow init` | Primeira instalação (rules + task-flow) |
 | `rbin-task-flow reset` | Recria `.task-flow` do zero |
+| `rbin-task-flow reset --keep-tasks` | Sobe versão sem sobrescrever `tasks.input.txt`, `tasks.status.md`, `.internal/` |
 | `rbin-task-flow reset --graphify` | Reset + `graphify extract . --backend claude-cli` |
+| `rbin-task-flow reset --keep-tasks --graphify` | Upgrade + mantém tasks + grafo |
 
 O Agent executa o workflow (`task-flow: audit`, `task-flow: run`, etc.); o CLI prepara arquivos.
 
 ---
 
-## 11. `.gitignore` discreto vs time
+## 11. `.gitignore` no projeto
 
-**Padrão:** `rbin-task-flow init` ignora `.cursor/` inteiro (skills e rules ficam locais).
-
-**Time:** `rbin-task-flow init --share-ai-config` — **não** ignora `.cursor/skills/` nem `.cursor/rules/`; ignora só `.cursor/settings.json` e `*.local.mdc`. O bloco no `.gitignore` explica o trade-off **tokens vs consistência do time**.
-
-| Estratégia | Comando | Prós | Contras |
-|------------|---------|------|---------|
-| Local (padrão) | `init` | Repo limpo; cada dev com setup próprio | Sem sync de rules/skills |
-| Time | `init --share-ai-config` | Mesmo Task Flow para todos | Mais arquivos de IA no git; tokens por dev ao usar rules |
-
-`update` sem flag reaplica a opção salva em `.task-flow/install-meta.json` (`shareAiConfig`).
-
-Para open source: documente no README — contribuidores podem usar `--share-ai-config` ou `init` local.
+**Padrão:** `init` / `reset` acrescentam `.task-flow` ao final do `.gitignore`.
 
 ---
 
@@ -268,7 +258,7 @@ Para open source: documente no README — contribuidores podem usar `--share-ai-
 
 | Problema | Causa provável | Ação |
 |----------|----------------|------|
-| Agent ignora `task-flow:` | Rules não instaladas / projeto errado | `rbin-task-flow update` |
+| Agent ignora `task-flow:` | Rules não instaladas / projeto errado | `rbin-task-flow reset --keep-tasks` |
 | Não atualiza `tasks.status.md` | Só mexeu em `status.json` | `@task-flow-run` — regenerar Summary |
 | `run 3` não roda | Tasks 1–2 incompletas | `task-flow: status` |
 | Coding standards ignorados | Checklist não no contexto | `@rbin-coding-standards` ou abrir arquivo em `src/` |