rbin-task-flow 1.25.1 → 1.26.1

package/.claude/skills/rbin-coding-standards/SKILL.md

@@ -15,7 +15,7 @@ paths: ["src/**", "app/**"]
 2. Implement using checklist rules: `app/` thin, `features/`, `shared/`, service+use-case, RHF+zod+`Controller`, `cn()`, no `any`, no raw base UI.
 3. **Vercel projects:** env files per **Vercel — environment variables** in `coding-standards-full.md` (§0–§8).
 4. **Only if ambiguous** (Nest gateways, DataHandler, route groups, naming edge case): open **one or two sections** of `.task-flow/guides/coding-standards-full.md` — never paste or load the whole file.
-5. If `graphify-out/graph.json` exists, `graphify query` before choosing file paths for new code.
+5. If `.task-flow/guides/graphify-out/graph.json` exists, `graphify query` before choosing file paths for new code.
 6. No explanatory code comments; use `dev-logs/` for non-obvious design notes.
 
 ## Token discipline

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

@@ -1,7 +1,7 @@
 ---
 name: task-flow-audit
 description: Audits the full codebase against RBIN coding standards with a score table and asks which improvements to adopt. Use when the user says task-flow audit or audit coding standards for the whole project.
-disable-model-invocation: true
+disable-model-invocation: false
 ---
 
 # Task Flow — Audit

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

@@ -1,15 +1,18 @@
 ---
 name: task-flow-estimate
-description: Estimates hours for RBIN Task Flow tasks for an average developer at average pace without AI acceleration. Use when the user says task-flow estimate X, estimate task 1, or time estimate for tasks.
-disable-model-invocation: true
+description: Estimates hours for RBIN Task Flow tasks (single ID, comma-separated IDs, or all). Use when the user says task-flow estimate 1, estimate 1,2, estimate all, or time estimate for tasks.
+disable-model-invocation: false
 paths: [".task-flow/**"]
 ---
 
 # Task Flow — Estimate
 
-1. Read `.task-flow/.internal/tasks.json` for task ID(s) or all.
-2. Infer complexity (low/medium/high) from title, description, subtasks, risk — not subtask count alone.
-3. Output single range in hours, e.g. `10-14 hours`.
-4. State assumption: average developer, average pace, no AI acceleration.
+1. Parse intent: `estimate X` | `estimate X,Y` | `estimate all`.
+2. Read `.task-flow/.internal/tasks.json` for the matching task ID(s).
+3. Infer complexity (low/medium/high) from title, description, subtasks, risk — not subtask count alone.
+4. Output one range in hours per task, e.g. `10-14 hours`.
+5. State assumption: average developer, average pace, no AI acceleration.
+
+**CLI (optional):** `rbin-task-flow estimate 1` · `rbin-task-flow estimate 1,2` · `rbin-task-flow estimate all`
 
 Reference: `.cursor/rules/task_estimate.mdc`

package/.claude/skills/task-flow-from-contexts/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: task-flow-from-contexts
+description: Creates tasks in tasks.input.txt from files in .task-flow/contexts/ (images, PDF, text, etc.). Use when the user says task-flow from contexts, import contexts, gerar tasks dos contexts, or criar tasks a partir dos contexts.
+disable-model-invocation: false
+paths: [".task-flow/**"]
+---
+
+# Task Flow — From contexts
+
+1. List `.task-flow/contexts/` (optional scope: one file or comma-separated list).
+2. Read each context (text directly; images/PDF with vision when available).
+3. Skip files already referenced via `task-flow-screen` in `tasks.input.txt`.
+4. Append new `- Description task-flow-screen filename.ext` lines under `## Tasks:`.
+5. Report added/skipped lines; suggest `task-flow: sync` — do **not** sync automatically.
+
+Reference: `.cursor/rules/task_from_contexts.mdc`

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

@@ -1,7 +1,7 @@
 ---
 name: task-flow-report
 description: Generates implementation markdown report for completed RBIN Task Flow tasks. Use when the user says task-flow report X or document completed task.
-disable-model-invocation: true
+disable-model-invocation: false
 paths: [".task-flow/**"]
 ---
 

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

@@ -1,7 +1,7 @@
 ---
 name: task-flow-run
 description: Executes RBIN Task Flow subtasks from tasks.json and status.json. Use when the user says task-flow run, run next X subtasks, work on task N, execute pending subtasks, implement task flow, or trabalhar nas próximas subtarefas.
-disable-model-invocation: true
+disable-model-invocation: false
 paths: [".task-flow/**"]
 ---
 
@@ -18,7 +18,7 @@ paths: [".task-flow/**"]
 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 `graphify-out/graph.json` exists, prefer `graphify query "<module from subtask>"` before broad grep (summarized output only — see GRAPHIFY.md).
+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`.

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

@@ -1,7 +1,7 @@
 ---
 name: task-flow-status
 description: Shows RBIN Task Flow progress from tasks.status.md. Use when the user says task-flow status, show task status, status das tasks, or ver progresso das tarefas.
-disable-model-invocation: true
+disable-model-invocation: false
 ---
 
 # Task Flow — Status

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

@@ -1,7 +1,7 @@
 ---
 name: task-flow-sync
 description: Synchronizes RBIN Task Flow tasks.input.txt with tasks.json, status.json, and tasks.status.md. Use when the user says task-flow sync, sync tasks, sincronizar tasks, or after editing tasks.input.txt.
-disable-model-invocation: true
+disable-model-invocation: false
 paths: [".task-flow/**"]
 ---
 
@@ -18,7 +18,6 @@ paths: [".task-flow/**"]
 7. **Unchanged:** leave task data and status as-is.
 8. Align `status.json` with `tasks.status.md` (`status.json` is source of truth).
 9. Regenerate 📊 Summary in `tasks.status.md`.
-10. Do **not** populate `tasks.flow.md` (only `task-flow: generate flow`).
 
 ## Contexts
 

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

@@ -50,7 +50,7 @@ All subtasks `pending`; task `pending`.
 
 - Preserve status on modified tasks when subtasks still match.
 - New subtasks after regen → `pending`; removed subtasks → drop from status.
-- Never explore codebase during pure sync unless user asked `think` in same message.
+- Never explore codebase during pure sync unless user explicitly asks for codebase analysis in the same message.
 
 ## After sync
 

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

@@ -1,12 +1,12 @@
 ---
 name: task-flow-validate
 description: Deep-validates RBIN Task Flow tasks against the codebase, reverts false done status, and appends missing gaps to tasks.input.txt then syncs. Use when the user says task-flow validate, validate all, validar tasks, or verificar lacunas.
-disable-model-invocation: true
+disable-model-invocation: false
 ---
 
 # Task Flow — Validate
 
-Thorough implementation audit + automatic gap fill (unlike `review` or `think`).
+Thorough implementation audit + automatic gap fill in `tasks.input.txt`.
 
 1. Read `tasks.input.txt`, `tasks.json`, `status.json`, `contexts/` — scope `X`, `X,Y`, or `all` (default `all`).
 2. **Verify** each subtask in scope: `done` must match code; `pending` checked for drift.
@@ -17,6 +17,6 @@ Thorough implementation audit + automatic gap fill (unlike `review` or `think`).
    - Run sync workflow (`@task-flow-sync` / `task-flow-sync.mdc`)
 5. Report verified / reverted / added / next `run`.
 
-Optional: `graphify query` per task area if `graphify-out/graph.json` exists.
+Optional: `graphify query` per task area if `.task-flow/guides/graphify-out/graph.json` exists.
 
 Reference: `.cursor/rules/task_validate.mdc`

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

@@ -1,21 +1,20 @@
 ---
-description: Use Graphify knowledge graph only when executing RBIN Task Flow commands that need codebase navigation (task-flow run, think, review, audit). Prefer graphify query over blind grep when graphify-out exists. Never override task-flow status updates or git rules.
+description: Use Graphify knowledge graph only when executing RBIN Task Flow commands that need codebase navigation (task-flow run, validate, audit). Prefer graphify query over blind grep when .task-flow/guides/graphify-out exists. Never override task-flow status updates or git rules.
 alwaysApply: false
 ---
 
 - **Graphify + RBIN Task Flow (coexistence):**
-  - **Graphify** maps repo structure (`graphify-out/graph.json`, `GRAPH_REPORT.md`). **Task Flow** owns tasks (`.task-flow/`), status, and commands `task-flow: …`.
+  - **Graphify** maps repo structure (`.task-flow/guides/graphify-out/graph.json`, `GRAPH_REPORT.md`). **Task Flow** owns tasks (`.task-flow/`), status, and commands `task-flow: …`.
   - **Do not compete:** Task Flow rules (`task_work`, `task-flow-sync`, `rbin-git-policy`, etc.) always win for workflow, git, and status files.
 
 - **When to use Graphify:**
-  - **`task-flow: run` / `run next X`:** Before implementing a subtask in a non-trivial codebase, if `graphify-out/graph.json` exists, use `graphify query "<feature or module from subtask>"` or read `graphify-out/GRAPH_REPORT.md` god nodes — then implement. If no graph exists, proceed with normal search or suggest `graphify extract . --backend claude-cli` (or `rbin-task-flow init --graphify`).
-  - **`task-flow: think`:** Optional `graphify query` for gap analysis on large repos.
-  - **`task-flow: review X`:** Optional `graphify affected "<symbol>"` to verify impact surface.
+  - **`task-flow: run` / `run next X`:** Before implementing a subtask, if `.task-flow/guides/graphify-out/graph.json` exists, use `graphify query "<feature or module from subtask>" --graph .task-flow/guides/graphify-out/graph.json` or read `GRAPH_REPORT.md` god nodes — then implement. If no graph exists, suggest `graphify extract . --backend claude-cli --out .task-flow/guides` (or `rbin-task-flow init --graphify`).
+  - **`task-flow: validate`:** Optional `graphify query` / `graphify affected` per task area when verifying implementation.
   - **`task-flow: validate`:** Optional `graphify query` per task area before verifying implementation; then append lacunas + sync per `task_validate.mdc`.
   - **`task-flow: audit`:** Graphify is structural only; scoring uses [coding_standards.mdc](mdc:.cursor/rules/coding_standards.mdc) checklist. Deep dive: sections of [coding-standards-full.md](mdc:.task-flow/guides/coding-standards-full.md) only if user asks for depth.
 
 - **When NOT to use Graphify:**
-  - `task-flow: sync`, `status`, `estimate`, `report`, `generate flow` — only `.task-flow/` files.
+  - `task-flow: sync`, `status`, `estimate`, `report` — only `.task-flow/` files.
   - Updating `status.json` / `tasks.status.md` — never defer to Graphify.
   - Git write operations — [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc) only suggests commits.
 
@@ -24,8 +23,8 @@ alwaysApply: false
   - RBIN Task Flow init sets upstream `graphify.mdc` to `alwaysApply: false` to save context.
 
 - **CLI (project root):**
-  - Build graph: `graphify extract . --backend claude-cli` or `rbin-task-flow init --graphify` (re-run after large refactors).
-  - Query: `graphify query "question"` · `graphify affected "node"`.
+  - Build graph: `graphify extract . --backend claude-cli --out .task-flow/guides` or `rbin-task-flow init --graphify` (re-run after large refactors).
+  - Query: `graphify query "question" --graph .task-flow/guides/graphify-out/graph.json` · `graphify affected "node" --graph .task-flow/guides/graphify-out/graph.json`.
   - Guide: [.task-flow/guides/GRAPHIFY.md](mdc:.task-flow/guides/GRAPHIFY.md)
 
 - **Principle:**

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

@@ -21,18 +21,13 @@ alwaysApply: true
 | User intent | Invoke |
 |-------------|--------|
 | `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: status` | `@task-flow-status` |
-| `task-flow: think` | `@task-flow-think` |
-| `task-flow: check` | `@task-flow-check` |
 | `task-flow: audit` | `@task-flow-audit` |
-| `task-flow: improve changes` | `@task-flow-improve-changes` |
-| `task-flow: review X` | `@task-flow-review` |
 | `task-flow: validate` | `@task-flow-validate` |
-| `task-flow: refactor X` | `@task-flow-refactor` |
-| `task-flow: estimate X` | `@task-flow-estimate` |
+| `task-flow: estimate X` / `X,Y` / `all` | `@task-flow-estimate` |
 | `task-flow: report X` | `@task-flow-report` |
-| `task-flow: generate flow` | `@task-flow-generate-flow` |
 | Implementing code | `@rbin-coding-standards` |
 | Suggest commit | `@rbin-git` |
 
@@ -44,7 +39,7 @@ Never write git — user runs all commits. Policy: [rbin-git-policy.mdc](mdc:.cu
 
 ## Graphify (optional)
 
-On `run` / `think`, if `graphify-out/` exists: `graphify query` before repo-wide grep. Rule: `graphify-task-flow`. Guide: `.task-flow/guides/GRAPHIFY.md`.
+On `run` / `validate`, if `.task-flow/guides/graphify-out/` exists: `graphify query` before repo-wide grep. Rule: `graphify-task-flow`. Guide: `.task-flow/guides/GRAPHIFY.md`.
 
 ## More detail
 

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

@@ -6,7 +6,7 @@ alwaysApply: false
 
 # task-flow: sync
 
-**Prefer:** `@task-flow-sync` · Skill workflow: `.claude/skills/task-flow-sync/workflow.md`
+**Prefer:** `@task-flow-sync` · Skill: `.claude/skills/task-flow-sync/workflow.md` · Works with `/task-flow-sync` and `task-flow: sync`.
 
 ## 1. Read
 
@@ -33,7 +33,7 @@ Task IDs stay sequential (1, 2, 3…) matching `tasks.input.txt` order.
 - Subtask instructions: **checklist** in [coding_standards.mdc](mdc:.cursor/rules/coding_standards.mdc) only — not [coding-standards-full.md](mdc:.task-flow/guides/coding-standards-full.md)
 - More templates: [task_generation.mdc](mdc:.cursor/rules/task_generation.mdc)
 
-**Sync rules:** no codebase exploration; no questions; do not fill `tasks.flow.md` (only `generate flow`).
+**Sync rules:** no codebase exploration; no questions.
 
 ## 4. Align status
 

package/.cursor/rules/task_execution.mdc

@@ -12,18 +12,13 @@ alwaysApply: false
 | Command | Invoke |
 |---------|--------|
 | `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: status` | `@task-flow-status` |
-| `task-flow: think` | `@task-flow-think` |
-| `task-flow: check` | `@task-flow-check` |
 | `task-flow: audit` | `@task-flow-audit` |
-| `task-flow: improve changes` | `@task-flow-improve-changes` |
-| `task-flow: review X` | `@task-flow-review` |
 | `task-flow: validate` | `@task-flow-validate` |
-| `task-flow: refactor X` | `@task-flow-refactor` |
-| `task-flow: estimate X` | `@task-flow-estimate` |
+| `task-flow: estimate X` / `X,Y` / `all` | `@task-flow-estimate` |
 | `task-flow: report X` | `@task-flow-report` |
-| `task-flow: generate flow` | `@task-flow-generate-flow` |
 | Implement code | `@rbin-coding-standards` |
 | Suggest commit | `@rbin-git` |
 

package/.cursor/rules/task_from_contexts.mdc

@@ -0,0 +1,93 @@
+---
+description: Drafts tasks in tasks.input.txt from files in .task-flow/contexts/. Use for task-flow from contexts, import contexts, gerar tasks dos contexts.
+alwaysApply: false
+---
+
+# task-flow: from contexts
+
+**Prefer:** `@task-flow-from-contexts` · **Next step:** `task-flow: sync` (user runs separately).
+
+## When to run
+
+User says `task-flow: from contexts`, `from contexts`, `import contexts`, `gerar tasks dos contexts`, `criar tasks a partir dos contexts`, etc.
+
+**Optional scope:** `task-flow: from contexts file.png` or `file1.png,file2.md` — only those files under `.task-flow/contexts/`.
+
+Default scope: **all context files** not yet represented in `tasks.input.txt`.
+
+## What it does
+
+Reads specs/mockups in `.task-flow/contexts/` and **appends** new `- Task description` lines to `.task-flow/tasks.input.txt`. Does **not** run sync, edit `.internal/`, or remove existing task lines.
+
+## Process
+
+### 1. Discover contexts
+
+- List `.task-flow/contexts/` (top level; include subfolders if present).
+- **Skip:** dotfiles, `README*`, and files that only document how `contexts/` works (e.g. `example.png.txt` unless user scoped it).
+- Supported: images (`.png`, `.jpg`, `.webp`, `.gif`), text (`.md`, `.txt`), data (`.json`, `.yaml`, `.yml`), PDF when the environment can read them.
+
+### 2. Read existing tasks
+
+- Parse `.task-flow/tasks.input.txt` — lines starting with `- `.
+- A context file is **already covered** if `tasks.input.txt` contains `task-flow-screen <filename>` or an equivalent reference to that basename.
+
+### 3. Analyze each new context file
+
+- **Text / markdown / JSON / YAML:** read and infer the deliverable (screen, API, feature, doc, fix).
+- **Images:** inspect visually (mockup, wireframe, diagram) and infer UI/feature scope.
+- **PDF:** extract requirements when readable; otherwise note limitation in the report.
+- Group related files into **one task** only when clearly one deliverable (e.g. `login.png` + `login-spec.md`); otherwise **one task per file**.
+
+### 4. Draft task lines
+
+Format (same as manual tasks):
+
+```text
+- Short actionable description task-flow-screen filename.ext
+```
+
+Rules:
+
+- One line per task; start with `- `; natural language; imperative tone.
+- Always append `task-flow-screen <exact-basename>` when the task comes from a file in `contexts/` (sync uses this in subtask instructions).
+- Do **not** duplicate meaning or `task-flow-screen` refs already in `tasks.input.txt`.
+- Do **not** edit or delete existing lines.
+
+### 5. Write
+
+- Append new lines under the `## Tasks:` section (or at end of task list if that heading is missing).
+- Preserve comments, headings, and blank lines elsewhere in the file.
+
+### 6. Report
+
+```markdown
+## From contexts
+
+### Added to tasks.input.txt
+- `- … task-flow-screen foo.png`
+- (none — all contexts already had tasks)
+
+### Skipped
+- `example.png.txt` — folder documentation
+- `bar.png` — already referenced in tasks.input.txt
+
+### Next
+Run `task-flow: sync` to generate subtasks.
+```
+
+## Variants
+
+| Intent | Example |
+|--------|---------|
+| All new contexts | `task-flow: from contexts` |
+| Specific file(s) | `task-flow: from contexts login-mockup.png` |
+| Multiple files | `task-flow: from contexts a.png,b.md` |
+
+## Integration
+
+- Sync after: [task-flow-sync.mdc](mdc:.cursor/rules/task-flow-sync.mdc) / `@task-flow-sync`
+- Context linking in subtasks: [task_generation.mdc](mdc:.cursor/rules/task_generation.mdc)
+- Git: [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc) — suggest commit after user syncs if they want
+
+**Principle:** Contexts hold the spec; this command turns them into task lines; sync turns lines into subtasks.

package/.cursor/rules/task_validate.mdc

@@ -7,10 +7,6 @@ alwaysApply: false
 
 **Prefer:** `@task-flow-validate` · After changes: status is updated automatically; new lines trigger sync.
 
-**Not the same as:**
-- `task-flow: review` — only checks `done` subtasks; asks before status revert; does not add tasks.
-- `task-flow: think` — suggests tasks; **asks** before writing `tasks.input.txt`.
-
 ## When to run
 
 User says `task-flow: validate`, `task-flow: validate X`, `task-flow: validate all`, `validar tasks`, `verificar lacunas`, `validate implementation gaps`, etc.
@@ -19,7 +15,7 @@ Default scope when no ID: **`all`**.
 
 ## Depth
 
-Use **thorough** reasoning: read each subtask `instructions`, `.task-flow/contexts/` when cited, verify files/tests/docs in the codebase — not a shallow grep. Optional: `graphify query "<module>"` per task area when `graphify-out/graph.json` exists.
+Use **thorough** reasoning: read each subtask `instructions`, `.task-flow/contexts/` when cited, verify files/tests/docs in the codebase — not a shallow grep. Optional: `graphify query "<module>"` per task area when `.task-flow/guides/graphify-out/graph.json` exists.
 
 ## Process
 
@@ -92,8 +88,6 @@ Find work not covered by current tasks:
 ## Integration
 
 - Sync: [task-flow-sync.mdc](mdc:.cursor/rules/task-flow-sync.mdc)
-- Review (lighter): [task_review.mdc](mdc:.cursor/rules/task_review.mdc)
-- Think (suggest only): [task_analysis.mdc](mdc:.cursor/rules/task_analysis.mdc)
 - Git: [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc)
 
 **Principle:** Validate = truth check + fill gaps. Done means done; missing work becomes new tasks automatically.

package/.cursor/rules/task_work.mdc

@@ -23,7 +23,7 @@ Natural language (`work on next 3 subtasks`, `execute all subtasks of task 2`) =
 
 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 `graphify-out/` exists ([graphify-task-flow.mdc](mdc:.cursor/rules/graphify-task-flow.mdc)).
+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.

package/.task-flow/README.md

@@ -7,7 +7,6 @@
 ├── README.md              ← você está aqui
 ├── tasks.input.txt        ← defina tasks (`- descrição`)
 ├── tasks.status.md        ← progresso (auto; não editar)
-├── tasks.flow.md          ← deps/horas (task-flow: generate flow)
 ├── contexts/              ← specs, mockups
 ├── .internal/             ← tasks.json, status.json (sistema)
 └── guides/                ← documentação e configs
@@ -16,6 +15,7 @@
     ├── CODEX.md · CURSOR.md
     ├── coding-standards-full.md  ← inclui padrão .env Vercel (§ Vercel)
     ├── platforms/         ← Claude, Cursor, Codex
+    ├── graphify-out/      ← grafo Graphify (init --graphify)
     └── reports/           ← task-X-implementation.md
 ```
 
@@ -33,27 +33,57 @@
 | Otimização (tokens) | [guides/OPTIMIZATION-PLAN.md](guides/OPTIMIZATION-PLAN.md) |
 | Coding standards (full) | [guides/coding-standards-full.md](guides/coding-standards-full.md) (Vercel `.env` no topo) |
 
+## Graphify (opcional)
+
+Grafo em **`.task-flow/guides/graphify-out/`** (não na raiz do projeto).
+
+**Pré-requisito:** CLI `graphify` no PATH (`rbin-install-dev`) + `claude` autenticado (Claude Code).
+
+### Projeto novo
+
+```bash
+cd seu-projeto
+rbin-task-flow init --graphify
+```
+
+### Projeto que já usa Task Flow (atualizar pacote + migrar grafo)
+
+```bash
+npm install -g rbin-task-flow@latest
+cd seu-projeto
+rbin-task-flow update --graphify
+```
+
+O `update --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)
+
+```bash
+cd seu-projeto
+graphify extract . --backend claude-cli --out .task-flow/guides
+```
+
+### Na IA (`task-flow: run`)
+
+```text
+task-flow: run next 2 — se .task-flow/guides/graphify-out/ existir,
+graphify query "<módulo>" --graph .task-flow/guides/graphify-out/graph.json antes de editar.
+```
+
+Guia completo: [guides/GRAPHIFY.md](guides/GRAPHIFY.md).
+
 ## 🚀 Quick Commands
 
-| Command | Description |
-|---------|-------------|
-| `task-flow: sync` | Complete synchronization: adds new, removes deleted, updates modified, preserves status |
-| `task-flow: think` | Analyzes code and suggests new tasks |
-| `task-flow: validate` | 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` | Works on next X subtasks (e.g., `task-flow: run next 4`) |
-| `task-flow: run X` | Executes all pending subtasks of task X (e.g., `task-flow: run 1`) |
-| `task-flow: run X,Y` | Executes multiple tasks (e.g., `task-flow: run 10,11`) |
-| `task-flow: run all` | Executes all tasks |
-| `task-flow: review X` | Reviews specific task(s) (e.g., `task-flow: review 1` or `task-flow: review 10,11` or `task-flow: review all`) |
-| `task-flow: refactor X` | Refactors specific task(s) (e.g., `task-flow: refactor 1` or `task-flow: refactor 10,11` or `task-flow: refactor all`) |
-| `task-flow: estimate X` | Estimates time for task X (e.g., `task-flow: estimate 1` or `task-flow: estimate 10,11`) |
-| `task-flow: report X` | Generates implementation report for task X (e.g., `task-flow: report 1` or `task-flow: report 10,11`) |
-| `task-flow: generate flow` | Populates tasks.flow.md with dependencies, estimated hours, and AI model recommendations |
-| `task-flow: audit` | Audits codebase against **coding standards checklist**; full doc on demand |
-| `task-flow: check` | Run lint fix (if available) and build; fix any warnings or errors until both pass |
-| `task-flow: improve changes` | Audit only uncommitted files vs **checklist** (same as audit, scoped to diff) |
-| `rbin-task-flow audit` | **(CLI)** Lists files with unstaged changes (not yet `git add`) |
+| Command | Variants | Description |
+|---------|----------|-------------|
+| `task-flow: from contexts` | `file.ext` · `a.png,b.md` | Draft `- tasks` in `tasks.input.txt` from files in `contexts/` (then run `sync`) |
+| `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: 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 |
 
 **See complete details below ↓**
 
@@ -61,6 +91,20 @@
 
 ## Detailed Commands
 
+### `task-flow: from contexts`
+Reads files in `.task-flow/contexts/` (images, PDF, text, JSON, etc.) and **appends** task lines to `tasks.input.txt`.
+
+**Flow:** add context files → `from contexts` → `sync` → `run`.
+
+**Variants:**
+- `task-flow: from contexts` — all context files not yet linked in `tasks.input.txt`
+- `task-flow: from contexts login-mockup.png` — one file
+- `task-flow: from contexts mockup.png,spec.md` — comma-separated list
+
+Each new line uses `task-flow-screen filename.ext` so sync/run attach the right context to subtasks.
+
+Invoke: `@task-flow-from-contexts` / `/task-flow-from-contexts`.
+
 ### `task-flow: sync`
 Complete synchronization between `tasks.input.txt` and the system:
 - ✅ Adds new tasks from `tasks.input.txt`
@@ -69,9 +113,6 @@ Complete synchronization between `tasks.input.txt` and the system:
 - ✅ Preserves status (done/pending) of existing tasks
 - ✅ Synchronizes status between `status.json` and `tasks.status.md` (ensures they are always aligned)
 
-### `task-flow: think`
-Analyzes code and suggests new tasks. Asks before adding to `tasks.input.txt`.
-
 ### `task-flow: validate`
 Deep validation: checks subtasks against the codebase, reverts false `done`, appends lacunas to `tasks.input.txt`, and syncs. Invoke: `@task-flow-validate` / `/task-flow-validate`.
 
@@ -81,15 +122,6 @@ Shows current status of tasks and subtasks from the `tasks.status.md` file.
 ### `task-flow: audit`
 Audits the **entire codebase** against the **checklist** in [coding_standards.mdc](../.cursor/rules/coding_standards.mdc). Deep reference: [guides/coding-standards-full.md](guides/coding-standards-full.md) (sections only, on demand). Non-destructive: reports gaps and suggests incremental improvements; the user chooses what to adopt. See [task_audit.mdc](../.cursor/rules/task_audit.mdc) for the full flow.
 
-### `task-flow: check`
-Runs **lint fix** and **build** for the project. Check `package.json` for a lint-with-fix script (e.g. `lint:fix`, `lint -- --fix`) and a build script; run lint fix first, fix any warnings or errors, then run build and fix until it passes. Use before committing or before `task-flow: improve changes` to ensure the project is clean.
-
-### `task-flow: improve changes`
-Same as **task-flow: audit**, but **only for files that were changed and not yet committed** (unstaged + staged). The AI obtains the list via `git diff --name-only HEAD`, and scores those paths against the **checklist** in `coding_standards.mdc` (not the full standards doc unless depth is needed). Use before committing. Does **not** run lint or build — use `task-flow: check` for that.
-
-### `rbin-task-flow audit` (CLI only)
-Lists **unstaged** file paths (modified but not yet `git add`). Run in the project root: `rbin-task-flow audit`. Option: `-p, --path <path>`.
-
 ---
 
 ## Commands with Task ID
@@ -115,37 +147,22 @@ Executes all pending subtasks of a specific task. Implements and marks as "done"
 - `task-flow: run all` → All pending subtasks of all tasks
 - `task-flow: run 3` → Only executes if tasks 1 and 2 are complete
 
-### `task-flow: review X`
-Reviews specific task(s) marked as "done" to verify they are actually completed.
-
-**Examples:**
-- `task-flow: review 1` → Reviews task 1
-- `task-flow: review 10,11` → Reviews tasks 10 and 11
-- `task-flow: review all` → Reviews all tasks
-
-### `task-flow: refactor X`
-Refactors code from specific task(s). Removes explanatory comments, improves code without changing functionality.
-
-**Examples:**
-- `task-flow: refactor 1` → Refactors task 1
-- `task-flow: refactor 10,11` → Refactors tasks 10 and 11
-- `task-flow: refactor all` → Refactors all tasks
-
 ### `task-flow: estimate X` (simplified syntax)
 Estimates time required to complete task(s) based on the real complexity of the task, assuming an average developer working at an average pace without AI acceleration. Subtask count informs scope, but is not the sole criterion.
 
+**Syntax:** one ID (`1`), comma-separated IDs (`10,11`), or `all`.
+
 **Output includes:**
 - A single estimate range for the majority of developers
 - Estimates in hours and business days
 - Recommendation for management with buffer
 
 **Examples:**
-- `task-flow: estimate 1` → Shows time estimate for task 1
-- `task-flow: estimate 10,11` → Shows time estimates for tasks 10 and 11
-- `task-flow: estimate all` → Shows time estimates for all tasks
+- `task-flow: estimate 1` → time estimate for task 1
+- `task-flow: estimate 10,11` → time estimates for tasks 10 and 11
+- `task-flow: estimate all` → time estimates for all tasks
 
-### `task-flow: generate flow`
-Populates `tasks.flow.md` with: (1) task dependencies (for parallelization), (2) estimated hours, and (3) AI model recommendations (GPT-5.x, Composer, Claude) with effort levels. Model ranking and effort must be defined by the AI from task context, not from a fixed order or only from subtask count. Run after `task-flow: sync` when you want to know which tasks can run in parallel and which model/effort to use.
+**CLI:** `rbin-task-flow estimate 1` · `rbin-task-flow estimate 1,2` · `rbin-task-flow estimate all`
 
 ### `task-flow: report X` (simplified syntax)
 Generates a detailed implementation report for completed task(s) in Markdown format.

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

@@ -30,12 +30,11 @@ Os comandos `task-flow: …` são **os mesmos** em Claude Code, Cursor e Codex.
 
 ## Fluxo comum (todas as plataformas)
 
-1. Editar `.task-flow/tasks.input.txt`
+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. `task-flow: check`
-6. **Você** faz `git commit` (a IA só sugere)
+5. **Você** faz `git commit` (a IA só sugere)
 
 Detalhes dos comandos: [README.md](../README.md).
 
@@ -56,7 +55,7 @@ Detalhes dos comandos: [README.md](../README.md).
 | `.codex/config.toml` | — | — | ✅ (opcional, preservado no update) |
 | `task-flow-cursor.mdc` | — | ✅ always-on | — |
 | `rbin-git-policy.mdc` | — | ✅ always-on | — |
-| `.claude/skills/` | ✅ (15 skills) | — | — |
+| `.claude/skills/` | ✅ (10 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.
@@ -67,10 +66,10 @@ Por padrão, `.claude/`, `.cursor/`, `.task-flow/`, `CLAUDE.md` e `AGENTS.md` en
 
 Com o [Graphify](https://pypi.org/project/graphifyyy/) instalado (`rbin-install-dev`), o Task Flow inclui integração cooperativa:
 
-- Regra **`.cursor/rules/graphify-task-flow.mdc`** — só quando `task-flow: run`, `think`, `review`, etc. precisam navegar o código (`alwaysApply: false`).
-- **`graphify-out/`** no `.gitignore`.
+- Regra **`.cursor/rules/graphify-task-flow.mdc`** — só quando `task-flow: run`, `validate`, etc. precisam navegar o código (`alwaysApply: false`).
+- Grafo em **`.task-flow/guides/graphify-out/`** (dentro de `.task-flow/`, já gitignored).
 - Rebaixa **`graphify.mdc`** upstream para `alwaysApply: false` se existir.
-- **`rbin-task-flow init --graphify`** — roda `graphify extract . --backend claude-cli` após o init.
+- **`rbin-task-flow init --graphify`** — roda `graphify extract . --backend claude-cli --out .task-flow/guides` após o init.
 
 Guia completo: [GRAPHIFY.md](GRAPHIFY.md).