rbin-task-flow 1.27.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-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,7 +53,7 @@ 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) | — | — |

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

@@ -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,10 +238,11 @@ 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.
 
@@ -258,7 +259,7 @@ O Agent executa o workflow (`task-flow: audit`, `task-flow: run`, etc.); o CLI p
 | 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`).
+`reset` 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.
 
@@ -268,7 +269,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/` |

package/AGENTS.md

@@ -13,6 +13,7 @@
 | `.task-flow/.internal/tasks.json` | Task definitions |
 | `.task-flow/.internal/status.json` | Status source of truth |
 | `.task-flow/contexts/` | Specs/mockups for subtasks |
+| `.task-flow/dev-logs/` | Manual steps + conversation log (AI updates from chat) |
 
 ## Git
 
@@ -52,12 +53,13 @@ No explanatory comments. Complex topics → `dev-logs/*.md`. Allowed: `// ──
 ## Run (embedded)
 
 1. Read `tasks.json` + `status.json`.
-2. `run next X` (default X=1): next X **pending** subtasks in order 1.1, 1.2, …, 2.1…
-3. `run X` / `X,Y` / `all`: all pending for task(s); for `run X`, block if tasks `1..X-1` have any pending subtask.
-4. Per subtask: follow `instructions`; read `contexts/` if cited; implement + verify.
-5. If `.task-flow/guides/graphify-out/graph.json` exists, prefer `graphify query … --graph .task-flow/guides/graphify-out/graph.json` before repo-wide grep.
-6. Mark subtask `done` in `status.json`; update `tasks.status.md` Summary.
-7. Parent task `done` when all subtasks done. Suggest commit; never git write.
+2. **Resolve `manual` first:** read dev-logs + conversation; append Conversation log; mark `done` only when verified.
+3. `run next X` (default X=1): next X **pending** subtasks (skip unresolved `manual`).
+4. `run X` / `X,Y` / `all`: all pending for task(s); block if tasks `1..X-1` have non-`done` subtasks.
+5. Per subtask: `instructions`; `contexts/`; implement + verify; optional `graphify query`.
+6. **Automatable** → `done`; **manual intervention** → `manual` + dev-log; user reports in chat; AI updates log and completes when verified.
+7. Parent task `done` when all subtasks `done`. Suggest commit; never git write.
+8. **Never** write `guides/reports/` during run.
 
 ## Prompt templates (copy)
 

package/README.md

@@ -33,7 +33,7 @@
 <a id="português"></a>
 # 🇧🇷 Português
 
-> **v1.25.1** — Padrão `.env` Vercel nos coding standards. De **1.25.0**: `npm install -g rbin-task-flow@1.25.1` e `rbin-task-flow update`. [CHANGELOG](CHANGELOG.md) · [Publicação](RELEASE-1.25.1.md).
+> **v1.30.1** — `reset --keep-tasks`, sem comando `update`, subtarefas `manual` em `dev-logs/`. `npm install -g rbin-task-flow@1.30.1` e `rbin-task-flow reset --keep-tasks`. [CHANGELOG](CHANGELOG.md) · [Publicação](RELEASE-1.30.1.md).
 
 ## O Que É Este Projeto?
 
@@ -74,11 +74,12 @@ rbin-task-flow init
 rbin-task-flow init          # Inicializa no projeto atual
 rbin-task-flow init --profile minimal  # Só 2 regras always-on + skills (menos tokens no Cursor)
 rbin-task-flow init --share-ai-config  # Versiona .cursor/skills/ e .cursor/rules/ no git (time)
-rbin-task-flow update        # Atualiza configurações (mantém profile em install-meta.json)
-rbin-task-flow update --profile standard  # Passa a copiar todas as regras .mdc
+rbin-task-flow init --graphify  # Init + grafo em .task-flow/guides/graphify-out/
 rbin-task-flow reset         # Reinstala o Task Flow do zero
-rbin-task-flow update --graphify # Update + grafo em .task-flow/guides/graphify-out/
+rbin-task-flow reset --keep-tasks  # Sobe versão sem sobrescrever suas tasks
+rbin-task-flow reset --profile standard  # Passa a copiar todas as regras .mdc
 rbin-task-flow reset --graphify  # Reset + graphify extract (CLI Graphify no PATH)
+rbin-task-flow reset --keep-tasks --graphify  # Upgrade + mantém tasks + graphify extract
 rbin-task-flow version-check # Verifica atualizações de modelos
 rbin-task-flow info          # Mostra informações
 rbin-task-flow estimate <ids> # Estima tempo (ex: "1" ou "1,2" ou "all")
@@ -91,7 +92,7 @@ Após inicializar, use estes comandos na IA (Cursor/Claude/Codex) para gerenciar
 
 **Otimizar por plataforma:** [.task-flow/guides/AI-PLATFORMS.md](.task-flow/guides/AI-PLATFORMS.md) · [Claude](.task-flow/guides/platforms/claude-code.md) · [Cursor](.task-flow/guides/platforms/cursor.md) · [Codex](.task-flow/guides/platforms/codex.md) · [Graphify](.task-flow/guides/GRAPHIFY.md)
 
-**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).
+**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 reset --keep-tasks --graphify` no projeto (migra `graphify-out/` da raiz + regera grafo). **Manter suas tasks ao subir versão:** `rbin-task-flow reset --keep-tasks`. 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 11 skills para `.claude/skills/` e `.cursor/skills/` — use `/task-flow-split`, `/task-flow-sync`, `/task-flow-run`, etc.
 
@@ -110,7 +111,7 @@ Após inicializar, use estes comandos na IA (Cursor/Claude/Codex) para gerenciar
 | `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 next X` | **Automatiza** o trabalho nas próximas subtarefas | IA implementa o que pode; passos manuais → `dev-logs/`; você reporta no chat |
 | `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`) |
 | `task-flow: run all` | **Completa** todas as tarefas | Executa todas as tarefas pendentes |
@@ -271,11 +272,17 @@ Para atualizar configurações em um projeto existente:
 ```bash
 # Usando NPM (recomendado)
 cd /caminho/para/seu/projeto
-rbin-task-flow update
 
-# Para reiniciar o Task Flow do zero, incluindo .task-flow/.internal
+# Primeira instalação
+rbin-task-flow init
+
+# Subir versão do pacote mantendo suas tasks
+npm install -g rbin-task-flow@latest
+rbin-task-flow reset --keep-tasks
+rbin-task-flow reset --keep-tasks --graphify
+
+# Reiniciar o Task Flow do zero (perde tasks)
 rbin-task-flow reset
-# Com grafo de código (requer graphify no PATH):
 rbin-task-flow reset --graphify
 
 # Ou usando método legacy
@@ -416,7 +423,7 @@ Para problemas ou perguntas:
 <a id="english"></a>
 # 🇬🇧 English
 
-> **v1.25.1** — Vercel `.env` pattern in coding standards. From **1.25.0**: `npm install -g rbin-task-flow@1.25.1` then `rbin-task-flow update`. [CHANGELOG](CHANGELOG.md) · [Release guide](RELEASE-1.25.1.md).
+> **v1.30.1** — `reset --keep-tasks`, no `update` CLI, `manual` subtasks in `dev-logs/`. `npm install -g rbin-task-flow@1.30.1` then `rbin-task-flow reset --keep-tasks`. [CHANGELOG](CHANGELOG.md) · [Release guide](RELEASE-1.30.1.md).
 
 ## What Is This Project?
 
@@ -457,11 +464,12 @@ rbin-task-flow init
 rbin-task-flow init          # Initialize in current project
 rbin-task-flow init --profile minimal  # 2 always-on rules + skills only (lower Cursor token cost)
 rbin-task-flow init --share-ai-config  # Commit .cursor/skills and rules with the team
-rbin-task-flow update        # Update configs (keeps profile from .task-flow/install-meta.json)
-rbin-task-flow update --profile standard  # Install all .cursor/rules/*.mdc
+rbin-task-flow init --graphify  # Init + graph at .task-flow/guides/graphify-out/
 rbin-task-flow reset         # Reinstall Task Flow from scratch
-rbin-task-flow update --graphify # Update + graph at .task-flow/guides/graphify-out/
+rbin-task-flow reset --keep-tasks  # Upgrade package without overwriting your tasks
+rbin-task-flow reset --profile standard  # Install all .cursor/rules/*.mdc
 rbin-task-flow reset --graphify  # Reset + graphify extract (Graphify CLI on PATH)
+rbin-task-flow reset --keep-tasks --graphify  # Upgrade + keep tasks + graphify extract
 rbin-task-flow version-check # Check for model updates
 rbin-task-flow info          # Show information
 rbin-task-flow estimate <ids> # Estimate time (e.g., "1" or "1,2" or "all")
@@ -474,7 +482,7 @@ After initializing, use these commands in your AI (Cursor/Claude/Codex) to autom
 
 **Per-platform optimization:** [index](.task-flow/guides/AI-PLATFORMS.md) · [Claude](.task-flow/guides/platforms/claude-code.md) · [Cursor](.task-flow/guides/platforms/cursor.md) · [Codex](.task-flow/guides/platforms/codex.md) · [Graphify](.task-flow/guides/GRAPHIFY.md)
 
-**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).
+**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 reset --keep-tasks --graphify` (migrates legacy root `graphify-out/` + re-extracts). **Keep your tasks when upgrading:** `rbin-task-flow reset --keep-tasks`. See [.task-flow/README.md](.task-flow/README.md#graphify-opcional) · [GRAPHIFY.md](.task-flow/guides/GRAPHIFY.md).
 
 **Claude / Cursor skills (v1.20+):** installs 11 skills — use `/task-flow-split`, `/task-flow-sync`, `/task-flow-run`, etc.
 
@@ -493,7 +501,7 @@ After initializing, use these commands in your AI (Cursor/Claude/Codex) to autom
 | `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 next X` | **Automate** work on next subtasks | AI implements what it can; manual steps → `dev-logs/`; you report in chat |
 | `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`) |
 | `task-flow: run all` | **Complete** all tasks | Executes all pending tasks |
@@ -654,11 +662,17 @@ To update configs in an existing project:
 ```bash
 # Using NPM (recommended)
 cd /path/to/your/project
-rbin-task-flow update
 
-# To reset Task Flow from scratch, including .task-flow/.internal
+# First install
+rbin-task-flow init
+
+# Upgrade package while keeping your tasks
+npm install -g rbin-task-flow@latest
+rbin-task-flow reset --keep-tasks
+rbin-task-flow reset --keep-tasks --graphify
+
+# Reset Task Flow from scratch (loses tasks)
 rbin-task-flow reset
-# With code knowledge graph (requires graphify on PATH):
 rbin-task-flow reset --graphify
 
 # Or using legacy method

package/bin/cli.js

@@ -22,12 +22,16 @@ function addInstallCommand(name, description, extra = {}) {
     .option('-g, --graphify', 'Run graphify extract → .task-flow/guides/graphify-out/ (claude-cli backend; requires graphify CLI)')
     .option(
       '--profile <profile>',
-      'Cursor rules: minimal (2 always-on + skills) or standard (all rules); update without flag keeps .task-flow/install-meta.json'
+      'Cursor rules: minimal (2 always-on + skills) or standard (all rules); reset without flag keeps .task-flow/install-meta.json'
     )
     .option(
       '--share-ai-config',
       'Do not gitignore .cursor/skills/ or .cursor/rules/ (team can commit shared AI config; see .gitignore comment)'
     )
+    .option(
+      '--keep-tasks',
+      'Preserve tasks.input.txt, tasks.status.md, .internal/, and dev-logs/ on reset (upgrade package without losing task definitions)'
+    )
     .action(async (options) => {
       const targetPath = options.path || process.cwd();
       try {
@@ -39,6 +43,7 @@ function addInstallCommand(name, description, extra = {}) {
           graphify: options.graphify,
           profile,
           shareAiConfig,
+          keepTasks: options.keepTasks === true,
         });
       } catch (error) {
         console.error(chalk.red('\n' + error.message + '\n'));
@@ -48,7 +53,6 @@ function addInstallCommand(name, description, extra = {}) {
 }
 
 addInstallCommand('init', 'Initialize RBIN Task Flow in current directory');
-addInstallCommand('update', 'Update RBIN Task Flow in current directory', { update: true });
 addInstallCommand('reset', 'Reset RBIN Task Flow in current directory', { reset: true });
 
 program
@@ -93,9 +97,10 @@ program
     console.log(chalk.cyan('  rbin-task-flow init --profile minimal') + ' - Low-token install (2 always-on rules + skills)');
     console.log(chalk.cyan('  rbin-task-flow init --share-ai-config') + ' - Version .cursor/skills and rules in git');
     console.log(chalk.cyan('  rbin-task-flow init --graphify') + ' - Init + graphify extract --backend claude-cli (if CLI installed)');
-    console.log(chalk.cyan('  rbin-task-flow update') + '       - Update configurations');
     console.log(chalk.cyan('  rbin-task-flow reset') + '        - Reset task flow files from scratch');
+    console.log(chalk.cyan('  rbin-task-flow reset --keep-tasks') + ' - Upgrade package without overwriting tasks');
     console.log(chalk.cyan('  rbin-task-flow reset --graphify') + ' - Reset + graphify extract --backend claude-cli (if CLI installed)');
+    console.log(chalk.cyan('  rbin-task-flow reset --keep-tasks --graphify') + ' - Upgrade + keep tasks + graphify extract');
     console.log(chalk.cyan('  rbin-task-flow version-check') + ' - Check for model updates');
     console.log(chalk.cyan('  rbin-task-flow estimate <ids>') + ' - Estimate time (e.g., "1" or "1,2" or "all")');
     console.log(chalk.cyan('  rbin-task-flow report <ids>') + '  - Generate report (e.g., "1" or "1,2" or "all")');

package/lib/cursor.js

@@ -30,7 +30,7 @@ async function setupCursorIntegration(targetPath, options = {}) {
 
   if (profile === 'minimal') {
     showInfo('Minimal profile: 2 always-on rules; workflows via @task-flow-* skills only');
-    showInfo('Full rules: rbin-task-flow update --profile standard');
+    showInfo('Full rules: rbin-task-flow reset --profile standard --keep-tasks');
   } else {
     showInfo('Rules: 2 always-on + intelligent/glob rules; prefer @task-flow-* skills for workflows');
   }

package/lib/install.js

@@ -1,4 +1,5 @@
 const fs = require('fs-extra');
+const os = require('os');
 const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
@@ -23,7 +24,6 @@ const TEMPLATE_DIR = path.join(__dirname, '..');
 const PACKAGE_VERSION = require('../package.json').version;
 
 async function installInProject(targetPath, options = {}) {
-  const isUpdate = options.update || false;
   const isReset = options.reset || false;
 
   let profile;
@@ -42,8 +42,6 @@ async function installInProject(targetPath, options = {}) {
 
   if (isReset) {
     console.log(chalk.blue('♻️  Resetting RBIN Task Flow...'));
-  } else if (isUpdate) {
-    console.log(chalk.blue('🔄 Updating RBIN Task Flow...'));
   } else {
     console.log(chalk.blue('🚀 Installing RBIN Task Flow...'));
   }
@@ -62,6 +60,12 @@ async function installInProject(targetPath, options = {}) {
       ? chalk.yellow('share-ai-config') + chalk.gray(' (.cursor/skills + .cursor/rules versionáveis)')
       : chalk.gray('local .cursor/ gitignored (default)')
   );
+  if (options.keepTasks) {
+    console.log(
+      chalk.blue('📋 Tasks:'),
+      chalk.yellow('keep-tasks') + chalk.gray(' (tasks.input.txt, tasks.status.md, .internal/, dev-logs/)')
+    );
+  }
   console.log('');
 
   const spinner = ora('Processing...').start();
@@ -81,8 +85,14 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Creating directories...';
 
+    let taskBackup = null;
+    const taskFlowPath = path.join(targetPath, '.task-flow');
+    if (isReset && options.keepTasks && (await fs.pathExists(taskFlowPath))) {
+      taskBackup = await backupTaskFiles(taskFlowPath);
+    }
+
     if (isReset) {
-      await fs.remove(path.join(targetPath, '.task-flow'));
+      await fs.remove(taskFlowPath);
     }
 
     const dirs = [
@@ -100,7 +110,12 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Copying configuration files...';
 
-    await copyConfigs(targetPath, { update: isUpdate, reset: isReset, profile });
+    await copyConfigs(targetPath, {
+      reset: isReset,
+      profile,
+      keepTasks: options.keepTasks === true,
+      taskBackup,
+    });
 
     spinner.text = 'Updating .gitignore...';
 
@@ -144,13 +159,12 @@ async function installInProject(targetPath, options = {}) {
 }
 
 async function copyConfigs(targetPath, options = {}) {
-  const isUpdate = options.update || false;
   const isReset = options.reset || false;
   const profile = options.profile;
+  const taskBackup = options.taskBackup || null;
 
   const rulesResult = await copyCursorRules(targetPath, TEMPLATE_DIR, {
     profile,
-    update: isUpdate,
     reset: isReset,
   });
   if (rulesResult?.mode === PROFILE_MINIMAL) {
@@ -200,7 +214,11 @@ async function copyConfigs(targetPath, options = {}) {
     showSuccess('Codex instructions (AGENTS.md)');
   }
 
-  await copyTaskFlow(targetPath, { update: isUpdate, reset: isReset });
+  await copyTaskFlow(targetPath, {
+    reset: isReset,
+    keepTasks: options.keepTasks === true,
+    taskBackup,
+  });
 }
 
 const LEGACY_TASK_FLOW_ROOT_FILES = [
@@ -255,9 +273,55 @@ async function migrateLegacyTaskFlowLayout(taskFlowDest) {
   }
 }
 
+async function backupTaskFiles(taskFlowDest) {
+  const backup = {};
+  const files = ['tasks.input.txt', 'tasks.status.md'];
+  for (const name of files) {
+    const filePath = path.join(taskFlowDest, name);
+    if (await fs.pathExists(filePath)) {
+      backup[name] = await fs.readFile(filePath, 'utf8');
+    }
+  }
+  const internalPath = path.join(taskFlowDest, '.internal');
+  if (await fs.pathExists(internalPath)) {
+    backup['.internal'] = await fs.mkdtemp(path.join(os.tmpdir(), 'rbin-task-flow-internal-'));
+    await fs.copy(internalPath, path.join(backup['.internal'], '.internal'));
+  }
+  const devLogsPath = path.join(taskFlowDest, 'dev-logs');
+  if (await fs.pathExists(devLogsPath)) {
+    backup['dev-logs'] = await fs.mkdtemp(path.join(os.tmpdir(), 'rbin-task-flow-dev-logs-'));
+    await fs.copy(devLogsPath, path.join(backup['dev-logs'], 'dev-logs'));
+  }
+  return backup;
+}
+
+async function restoreTaskFiles(taskFlowDest, backup) {
+  if (!backup) return;
+  for (const name of ['tasks.input.txt', 'tasks.status.md']) {
+    if (backup[name] !== undefined) {
+      await fs.writeFile(path.join(taskFlowDest, name), backup[name], 'utf8');
+    }
+  }
+  if (backup['.internal']) {
+    const src = path.join(backup['.internal'], '.internal');
+    if (await fs.pathExists(src)) {
+      await fs.copy(src, path.join(taskFlowDest, '.internal'), { overwrite: true });
+    }
+    await fs.remove(backup['.internal']);
+  }
+  if (backup['dev-logs']) {
+    const src = path.join(backup['dev-logs'], 'dev-logs');
+    if (await fs.pathExists(src)) {
+      await fs.copy(src, path.join(taskFlowDest, 'dev-logs'), { overwrite: true });
+    }
+    await fs.remove(backup['dev-logs']);
+  }
+}
+
 async function copyTaskFlow(targetPath, options = {}) {
-  const isUpdate = options.update || false;
   const isReset = options.reset || false;
+  const keepTasks = options.keepTasks === true;
+  const taskBackup = options.taskBackup || null;
   const taskFlowSrc = path.join(TEMPLATE_DIR, '.task-flow');
   const taskFlowDest = path.join(targetPath, '.task-flow');
 
@@ -271,11 +335,15 @@ async function copyTaskFlow(targetPath, options = {}) {
     path.join(taskFlowDest, 'tasks.status.md'),
     path.join(taskFlowDest, 'install-meta.json'),
   ];
+  const PRESERVED_KEEP_TASKS = [
+    path.join(taskFlowDest, 'tasks.input.txt'),
+    path.join(taskFlowDest, 'tasks.status.md'),
+  ];
 
   await fs.copy(taskFlowSrc, taskFlowDest, {
     overwrite: true,
     filter: (src, dest) => {
-      if (isReset) {
+      if (isReset && !keepTasks) {
         return true;
       }
 
@@ -283,7 +351,11 @@ async function copyTaskFlow(targetPath, options = {}) {
         return false;
       }
 
-      if (!isUpdate && PRESERVED_ON_INIT.includes(dest) && fs.existsSync(dest)) {
+      if (keepTasks && PRESERVED_KEEP_TASKS.includes(dest) && fs.existsSync(dest)) {
+        return false;
+      }
+
+      if (!isReset && !keepTasks && PRESERVED_ON_INIT.includes(dest) && fs.existsSync(dest)) {
         return false;
       }
 
@@ -291,15 +363,20 @@ async function copyTaskFlow(targetPath, options = {}) {
     },
   });
 
+  if (taskBackup) {
+    await restoreTaskFiles(taskFlowDest, taskBackup);
+  }
+
   await fs.ensureDir(path.join(taskFlowDest, 'contexts'));
+  await fs.ensureDir(path.join(taskFlowDest, 'dev-logs'));
   await fs.ensureDir(path.join(taskFlowDest, 'guides', 'reports'));
   await migrateLegacyTaskFlowLayout(taskFlowDest);
 
   showSuccess('Task Flow directory');
-  if (isReset) {
+  if (keepTasks) {
+    showInfo('Kept: tasks.input.txt, tasks.status.md, .internal/, dev-logs/');
+  } else if (isReset) {
     showWarning('Reset completed: .task-flow was recreated from scratch');
-  } else if (isUpdate) {
-    showInfo('Protected: .internal/ (your task data is safe)');
   } else {
     showInfo('Protected on init: .internal/, tasks.input.txt, tasks.status.md');
   }

package/lib/profiles.js

@@ -68,7 +68,7 @@ async function resolveProfile(targetPath, options = {}) {
   return PROFILE_STANDARD;
 }
 
-async function copyCursorRules(targetPath, templateDir, { profile, update, reset }) {
+async function copyCursorRules(targetPath, templateDir, { profile, reset }) {
   const src = path.join(templateDir, '.cursor', 'rules');
   const dest = path.join(targetPath, '.cursor', 'rules');
 
@@ -76,7 +76,7 @@ async function copyCursorRules(targetPath, templateDir, { profile, update, reset
     return;
   }
 
-  if ((update || reset) && fs.existsSync(dest)) {
+  if (reset && fs.existsSync(dest)) {
     await fs.emptyDir(dest);
   }
   await fs.ensureDir(dest);

package/lib/version.js

@@ -97,7 +97,7 @@ async function checkModelVersion(modelName, versionInfo, settingsPath, rl) {
         }
         await fs.writeJSON(fullSettingsPath, settings, { spaces: 2 });
         console.log(chalk.green(`  ✅ ${modelName} updated to ${versionInfo.latest}`));
-        console.log(chalk.cyan('     (Repository template updated - run init/update on projects to apply)'));
+        console.log(chalk.cyan('     (Repository template updated - run init/reset on projects to apply)'));
       } else {
         console.log(chalk.cyan('     Skipped update'));
       }

package/package.json

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