rbin-task-flow 1.19.5 → 1.23.0

package/.cursor/rules/task_improve_changes.mdc

@@ -1,14 +1,13 @@
 ---
-description: Audit only files changed in the current diff against coding standards
-globs: **/*
-alwaysApply: true
+description: Audits uncommitted files only for task-flow improve changes. Use git diff against HEAD scope.
+alwaysApply: false
 ---
 
 # task-flow: improve changes
 
 When the user runs `task-flow: improve changes`:
 
-1. **Audit current changes only**: Do the **same as** [task-flow: audit](mdc:.cursor/rules/task_audit.mdc) (codebase audit against [coding_standards.mdc](mdc:.cursor/rules/coding_standards.mdc)), but **restricted to files that were changed and not yet committed**.
+1. **Audit current changes only**: Do the **same as** [task-flow: audit](mdc:.cursor/rules/task_audit.mdc) (score against the [coding_standards.mdc](mdc:.cursor/rules/coding_standards.mdc) checklist; [full doc](mdc:.task-flow/docs/coding-standards-full.md) only if needed), but **restricted to files that were changed and not yet committed**.
 2. **Do not run project checks here**: Lint fix and build now belong to [task-flow: check](mdc:.cursor/rules/task_check.mdc).
 
 ---

package/.cursor/rules/task_refactor.mdc

@@ -1,7 +1,6 @@
 ---
-description: Refactor code from current commit tasks without changing functionality
-globs: **/*
-alwaysApply: true
+description: Refactors task-flow task code without behavior change. Use for task-flow refactor X.
+alwaysApply: false
 ---
 
 - **Task Refactor - Improve Code Quality:**
@@ -88,8 +87,8 @@ alwaysApply: true
 
 - **Integration:**
   - Follows [code_comments.mdc](mdc:.cursor/rules/code_comments.mdc) - comment removal rules
-  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
-  - Respects [git_control.mdc](mdc:.cursor/rules/git_control.mdc) - never commit automatically
+  - Works with [task-flow-cursor.mdc](mdc:.cursor/rules/task-flow-cursor.mdc) / `@task-flow-refactor`
+  - Respects [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc) — never commit automatically
 
 - **Principle:**
   > **Refactor code to improve quality without changing behavior. Remove explanatory comments, keep only separation comments, improve structure and naming. Code must work exactly the same.**

package/.cursor/rules/task_report.mdc

@@ -1,7 +1,6 @@
 ---
-description: Generate implementation reports for completed tasks
-globs: **/*
-alwaysApply: true
+description: Generates task-flow implementation report for completed task X. Use for task-flow report.
+alwaysApply: false
 ---
 
 - **Task Report - Generate Implementation Reports:**
@@ -104,7 +103,7 @@ alwaysApply: true
   - If docs directory doesn't exist: Create it automatically
 
 - **Integration:**
-  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
+  - Works with [task-flow-cursor.mdc](mdc:.cursor/rules/task-flow-cursor.mdc) / `@task-flow-report`
   - Uses task data from `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json`
   - Reports are stored in `.task-flow/docs/` directory
   - Can reference git history for implementation details

package/.cursor/rules/task_review.mdc

@@ -1,7 +1,6 @@
 ---
-description: Review completed tasks to verify they are actually done or erroneously marked
-globs: **/*
-alwaysApply: true
+description: Verifies completed task-flow tasks are actually implemented. Use for task-flow review X or review all.
+alwaysApply: false
 ---
 
 - **Task Review - Verify Completed Tasks:**
@@ -81,8 +80,8 @@ alwaysApply: true
   ```
 
 - **Integration:**
-  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
-  - Respects [git_control.mdc](mdc:.cursor/rules/git_control.mdc) - never commit automatically
+  - Works with [task-flow-cursor.mdc](mdc:.cursor/rules/task-flow-cursor.mdc) / `@task-flow-review`
+  - Respects [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc) — never commit automatically
 
 - **Principle:**
   > **Review completed tasks to ensure quality. Verify that "done" means actually done, not just marked. Help maintain accurate task status.**

package/.cursor/rules/task_status.mdc

@@ -1,7 +1,7 @@
 ---
-description: Show task status from tasks.status.md - simple and direct
-globs: **/*
-alwaysApply: true
+description: Shows RBIN Task Flow progress from tasks.status.md. Use for task-flow status or show task status.
+globs: .task-flow/**
+alwaysApply: false
 ---
 
 - **Task Status - Show Current Status:**
@@ -38,7 +38,7 @@ alwaysApply: true
   ```
 
 - **Integration:**
-  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) workflow
+  - Works with [task-flow-cursor.mdc](mdc:.cursor/rules/task-flow-cursor.mdc) / `@task-flow-status`
   - Status is maintained in tasks.status.md file
 
 - **Principle:**

package/.cursor/rules/task_work.mdc

@@ -1,223 +1,36 @@
 ---
-description: Work on next X subtasks from RBIN Task Flow - simplified commands
-globs: **/*
-alwaysApply: true
+description: Executes RBIN Task Flow subtasks — task-flow run, run next X, run task N, work on next subtasks. Prefer @task-flow-run skill; this rule is a short fallback only.
+alwaysApply: false
 ---
 
-- **Task Work - Simplified Commands:**
-  - **FASTEST FORMAT**: `task-flow: run next X` (e.g., "task-flow: run next 4" → work on next 4 subtasks)
-  - **TASK SPECIFIC**: `task-flow: run X` or `task-flow: run X,Y` or `task-flow: run all` (e.g., "task-flow: run 1" → work on all subtasks of task 1)
-  - **SIMPLIFIED SYNTAX**: No need to say "task" - just use the number: `task-flow: run 1` instead of `task-flow: run task 1`
-  - When user says "task-flow: run next X" or "work on next X subtasks":
-    - **INTERPRET**: User wants to work on the next X pending subtasks from RBIN Task Flow
-    - **AUTOMATIC**: Read tasks, find next X pending, implement them sequentially
-    - **UPDATE**: Mark each subtask as done after completion
-    - **NO NEED**: To specify "task flow" explicitly - it's implied
-  - When user says "task-flow: run X" or "task-flow: run X,Y" or "task-flow: run all":
-    - **INTERPRET**: User wants to work on all pending subtasks of specific task(s) or all tasks
-    - **MULTIPLE TASKS**: Comma-separated IDs (e.g., "10,11") processes multiple tasks sequentially
-    - **ALL TASKS**: "all" processes all tasks in order
-    - **DEPENDENCY CHECK**: Before executing, verify that all tasks before X (1, 2, ..., X-1) are completely done
-    - **CONFLICT PREVENTION**: Only execute subtasks of task X if no previous tasks have pending subtasks (allows parallel work by multiple AIs)
-    - **PARTIAL EXECUTION**: If previous tasks have pending subtasks, inform user that task X cannot be fully executed until previous tasks are complete
-    - **AUTOMATIC**: If no conflicts, read tasks, find all pending subtasks of task X, implement them sequentially
-    - **UPDATE**: Mark each subtask as done after completion
-    - **COMPLETE**: If all subtasks are done, mark the task as done
+# Task Flow — Run (fallback)
 
-- **Natural Language Phrases:**
-  - **FAST FORMAT**: `task-flow: run next X` or `task-flow run next X` (e.g., "task-flow: run next 4")
-  - **TASK FORMAT**: `task-flow: run X` or `task-flow: run X,Y` or `task-flow: run all` (e.g., "task-flow: run 1" or "task-flow: run 10,11" or "task-flow: run all")
-  - "work on next 3 subtasks"
-  - "work on next 5 subtasks"
-  - "next 2 subtasks"
-  - "work on next subtasks"
-  - "implement next X subtasks"
-  - "work on next X subtasks"
-  - "execute all subtasks of task 1"
-  - "work on all subtasks of task 2"
-  - Any phrase with "next" + number + "subtasks"
-  - Any phrase with "task" + number + "subtasks" or "all subtasks" + "task" + number
-  
-- **Fast Command Format:**
-  - `task-flow: run next X` → Work on next X subtasks sequentially (fastest way)
-  - `task-flow run next X` → Same as above (without colon)
-  - `task-flow: run next` → Work on next 1 subtask (default)
-  - `task-flow: run X` → Work on all pending subtasks of task X (simplified - no "task" needed)
-  - `task-flow: run X,Y` → Work on all pending subtasks of tasks X and Y
-  - `task-flow: run all` → Work on all pending subtasks of all tasks
-  - `task-flow run X` → Same as above (without colon)
-  - Examples:
-    - "task-flow: run next 4" → Work on next 4 subtasks
-    - "task-flow run next 3" → Work on next 3 subtasks
-    - "task-flow: run next" → Work on next 1 subtask
-    - "task-flow: run 1" → Work on all pending subtasks of task 1
-    - "task-flow: run 10,11" → Work on all pending subtasks of tasks 10 and 11
-    - "task-flow: run all" → Work on all pending subtasks of all tasks
+**Prefer:** `@task-flow-run` (Claude: `/task-flow-run`) — full steps in `.claude/skills/task-flow-run/workflow.md` (same under `.cursor/skills/` after install).
 
-- **Required Actions for `task-flow: run next X`:**
-  1. **Read task files**: `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json`
-  2. **Find next X pending subtasks**: 
-     - Sequential order: Task 1 → Subtask 1, 2, 3... → Task 2 → Subtask 1, 2, 3...
-     - Only count subtasks with status "pending"
-     - Skip "done" and "in_progress" subtasks
-  3. **For each subtask**:
-     - Read full instructions from `tasks.json`
-     - **CHECK**: If instructions mention context references (`.task-flow/contexts/...`), verify the context file exists
-     - **CONSULT**: Read and use context files from `.task-flow/contexts/` when implementing (images, .md, .txt, .json, etc. – any type that helps the task)
-     - Implement following step-by-step instructions
-     - Test/verify implementation
-     - Update `status.json` to mark as "done"
-     - Update `tasks.status.md` to reflect the new status
-  4. **After all X subtasks done**:
-     - Check if parent task is complete (all subtasks done)
-     - If complete, update task status to "done" in both `status.json` and `tasks.status.md`
-     - Show summary of what was completed
+**Task flow** = RBIN Task Flow. Do not edit `.task-flow/.internal/` by hand.
 
-- **Required Actions for `task-flow: run task X`:**
-  1. **Read task files**: `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json`
-  2. **Check dependencies (CRITICAL for parallel work)**:
-     - Check all tasks before X (tasks 1, 2, ..., X-1)
-     - Verify if any of these previous tasks have pending subtasks
-     - If ANY previous task has pending subtasks:
-       - **STOP**: Cannot execute task X subtasks (would conflict with sequential order)
-       - **INFORM**: Tell user which tasks need to be completed first
-       - **FORMAT**: "⚠️ Cannot execute task X: Tasks [list] must be completed first. Use 'task-flow: run task Y' to complete them."
-       - **DO NOT EXECUTE**: Do not execute any subtasks of task X
-     - If all previous tasks (1 to X-1) are completely done (all subtasks done):
-       - **PROCEED**: Safe to execute all subtasks of task X
-  3. **Find all pending subtasks of task X** (only if dependency check passed): 
-     - Only subtasks of the specified task X
-     - Only count subtasks with status "pending"
-     - Skip "done" and "in_progress" subtasks
-  4. **For each subtask** (only if dependency check passed):
-     - Read full instructions from `tasks.json`
-     - **CHECK**: If instructions mention context references (`.task-flow/contexts/...`), verify the context file exists
-     - **CONSULT**: Read and use context files from `.task-flow/contexts/` when implementing (images, .md, .txt, .json, etc. – any type that helps the task)
-     - Implement following step-by-step instructions
-     - Test/verify implementation
-     - Update `status.json` to mark as "done"
-     - Update `tasks.status.md` to reflect the new status
-  5. **After all subtasks of task X are done**:
-     - Update task X status to "done" in both `status.json` and `tasks.status.md`
-     - Show summary of what was completed
+## Commands
 
-- **Status Update Format:**
-  ```json
-  {
-    "tasks": {
-      "1": {
-        "status": "pending",
-        "subtasks": {
-          "1": "done",
-          "2": "done",
-          "3": "pending"
-        }
-      }
-    }
-  }
-  ```
+| 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 |
 
-- **Status Update Process:**
-  - When marking a subtask as done:
-    1. Read `.task-flow/.internal/tasks.json` and `.task-flow/.internal/status.json`
-    2. Update `.task-flow/.internal/status.json` (set subtask status to "done")
-    3. Update `.task-flow/tasks.status.md`:
-       - Change `- [ ]` to `- [x]` for the subtask
-       - If all subtasks of a task are done, mark task as `- [x]`
-       - **REGENERATE SUMMARY**: Always update the "📊 Summary" section at the top with:
-         - Count of completed tasks (✅)
-         - Count of in-progress tasks (⏳)
-         - Total remaining subtasks (📝)
-         - List each task with status and remaining subtasks count
-    4. Format for `tasks.status.md`: 
-       - Summary section at top (always regenerate)
-       - Tasks with `- [ ]` or `- [x]`, subtasks indented with `  - [ ]` or `  - [x]`
+Natural language (`work on next 3 subtasks`, `execute all subtasks of task 2`) = same as above.
 
-- **Examples:**
-  ```
-  User: "task-flow: run next 4"
-  AI Action:
-  1. Read .task-flow/.internal/tasks.json
-  2. Read .task-flow/.internal/status.json
-  3. Find next 4 pending subtasks sequentially (e.g., 1.2, 1.3, 1.4, 2.1)
-  4. Work on each subtask sequentially
-  5. Mark each as "done" in status.json and update tasks.status.md
-  6. Show completion summary
-  
-  User: "task-flow: run next"
-  AI Action: Same as above, but work on 1 subtask (default)
-  
-  User: "task-flow: run task 1"
-  AI Action:
-  1. Read .task-flow/.internal/tasks.json
-  2. Read .task-flow/.internal/status.json
-  3. Check dependencies: No tasks before task 1, so proceed
-  4. Find all pending subtasks of task 1 (e.g., 1.1, 1.2, 1.3)
-  5. Work on each subtask sequentially
-  6. Mark each as "done" in status.json and update tasks.status.md
-  7. Mark task 1 as "done" if all subtasks completed
-  8. Show completion summary
-  
-  User: "task-flow: run task 3"
-  AI Action (with task 2 incomplete):
-  1. Read .task-flow/.internal/tasks.json
-  2. Read .task-flow/.internal/status.json
-  3. Check dependencies: Task 2 has pending subtasks
-  4. STOP and inform: "⚠️ Cannot execute task 3: Task 2 must be completed first. Use 'task-flow: run task 2' to complete it."
-  5. Do not execute any subtasks of task 3
-  
-  User: "task-flow: run task 3"
-  AI Action (with task 2 complete):
-  1. Read .task-flow/.internal/tasks.json
-  2. Read .task-flow/.internal/status.json
-  3. Check dependencies: All tasks before 3 (1, 2) are done, so proceed
-  4. Find all pending subtasks of task 3 (e.g., 3.1, 3.2)
-  5. Work on each subtask sequentially
-  6. Mark each as "done" in status.json and update tasks.status.md
-  7. Mark task 3 as "done" if all subtasks completed
-  8. Show completion summary
-  
-  User: "work on next 3 subtasks"
-  AI Action: Same workflow as "run next 3", works with natural language too
-  
-  User: "execute all subtasks of task 2"
-  AI Action: Same workflow as "run task 2", includes dependency check
-  ```
+## Critical flow (each subtask)
 
-- **Default Behavior:**
-  - If user says "next subtasks" without number → assume 1 subtask
-  - If user says "next X subtasks" → work on exactly X subtasks
-  - If user says "task X" without "next" → interpret as "run task X" (all subtasks of that task)
-  - Always work sequentially (don't skip or reorder)
+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)).
+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.
 
-- **Completion Summary:**
-  After completing subtasks, show:
-  ```
-  ✅ Completed 3 subtasks:
-  - Task 1.2: [subtask title]
-  - Task 1.3: [subtask title]
-  - Task 2.1: [subtask title]
-  
-  📝 Next pending subtask: Task 2.2
-  ```
+If blocked: subtask `in_progress` + explain.
 
-- **Error Handling:**
-  - If subtask can't be completed → mark as "in_progress" and explain why
-  - If file doesn't exist → create it
-  - If instructions unclear → ask for clarification (but try to infer first)
+## More detail
 
-- **Context Support:**
-  - **PURPOSE**: `.task-flow/contexts/` holds reference material (any file type) for the AI to consult when working on tasks
-  - **AUTOMATIC**: When implementing subtasks, check if instructions reference context files
-  - **CONSULT**: Read and use files from `.task-flow/contexts/` as needed (specs, mockups, examples, .md, .txt, .png, .json, etc.)
-  - **MATCHING**: Use the context files mentioned in subtask instructions; support any extension, not only images
-  - **NO NEED**: User doesn't need to explicitly mention context files - they're automatically considered
-
-- **Integration:**
-  - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) - same workflow
-  - Follows [task_generation.mdc](mdc:.cursor/rules/task_generation.mdc) - context files are automatically referenced in generated subtasks
-  - Follows [commit_practices.mdc](mdc:.cursor/rules/commit_practices.mdc) - suggest commit after completion
-  - Respects [git_control.mdc](mdc:.cursor/rules/git_control.mdc) - never commit automatically
-
-- **Principle:**
-  > **When user asks to work on next X subtasks, automatically find them, implement them, and update status. Make it seamless - user shouldn't need to specify task IDs or check status manually.**
+- 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)

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

@@ -0,0 +1,104 @@
+# RBIN Task Flow — Guia por plataforma de IA
+
+Os comandos `task-flow: …` são **os mesmos** em Claude Code, Cursor e Codex. O que muda é **como cada ferramenta carrega instruções** — e como você extrai o melhor de cada uma.
+
+---
+
+## Escolha seu guia
+
+| Plataforma | Guia | Mecanismo nativo | Otimização RBIN hoje |
+|------------|------|------------------|----------------------|
+| **Claude Code** | [platforms/claude-code.md](platforms/claude-code.md) | `CLAUDE.md` + `.claude/skills/*/SKILL.md` | **Skills no `init`** — `/task-flow-run`, etc. |
+| **Cursor** | [platforms/cursor.md](platforms/cursor.md) | `task-flow-cursor.mdc` + `rbin-git-policy.mdc` + skills | **Otimizado v1.23** — 2 always-on + `@task-flow-*` |
+| **OpenAI Codex** | [platforms/codex.md](platforms/codex.md) | `AGENTS.md` + `.task-flow/CODEX.md` + `.codex/config.toml` | **Otimizado v1.21** — sync/run no AGENTS.md |
+
+---
+
+## Visão em 30 segundos
+
+```text
+.task-flow/          ← dados (tasks, status, contexts) — IGUAL para todas
+     │
+     ├── Claude  → CLAUDE.md (fino) + Skills (workflows)
+     ├── Cursor  → task-flow-cursor (sempre) + @skills + rules inteligentes
+     └── Codex   → AGENTS.md (compacto) + pedir .mdc no prompt
+```
+
+**Princípio:** Task Flow = **dados** em `.task-flow/` + **procedimentos** que a IA segue. Procedimentos devem viver no mecanismo nativo de cada ferramenta.
+
+---
+
+## Fluxo comum (todas as plataformas)
+
+1. Editar `.task-flow/tasks.input.txt`
+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)
+
+Detalhes dos comandos: [README.md](README.md).
+
+---
+
+## O que o `rbin-task-flow init` instala
+
+| Caminho | Claude | Cursor | Codex |
+|---------|--------|--------|-------|
+| `.task-flow/` | ✅ | ✅ | ✅ |
+| `.cursor/rules/` | leitura manual | ✅ auto | leitura manual |
+| `CLAUDE.md` | ✅ | — | — |
+| `AGENTS.md` | — | — | ✅ |
+| `.task-flow/CODEX.md` | — | — | ✅ |
+| `.task-flow/CURSOR.md` | — | ✅ | — |
+| `.task-flow/docs/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) |
+| `task-flow-cursor.mdc` | — | ✅ always-on | — |
+| `rbin-git-policy.mdc` | — | ✅ always-on | — |
+| `.claude/skills/` | ✅ (14 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.
+
+---
+
+## Graphify (opcional, sem competir)
+
+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`.
+- Rebaixa **`graphify.mdc`** upstream para `alwaysApply: false` se existir.
+- **`rbin-task-flow init --graphify`** — roda `graphify extract .` após o init.
+
+Guia completo: [GRAPHIFY.md](GRAPHIFY.md).
+
+---
+
+## Roadmap do pacote (alinhamento multi-IA)
+
+1. ~~Gerar `.claude/skills/` e `.cursor/skills/`~~ ✅ v1.20.0
+2. ~~`CLAUDE.md` índice curto~~ ✅
+3. ~~Reduzir `alwaysApply` no Cursor~~ ✅ v1.23 **2 always-on** (`task-flow-cursor`, `rbin-git-policy`) + skills
+4. ~~Opção de instalador `--share-ai-config`~~ → `rbin-task-flow init --share-ai-config` (P2.2)
+
+---
+
+## Referências cruzadas
+
+| Arquivo | Papel |
+|---------|--------|
+| [platforms/claude-code.md](platforms/claude-code.md) | Skills, frontmatter, injeção `!`cmd``, monorepo |
+| [platforms/cursor.md](platforms/cursor.md) | Modos de regra, inventário `.mdc`, Agent vs Chat |
+| [platforms/codex.md](platforms/codex.md) | 32 KiB, AGENTS.override, prompts eficazes |
+| [../CLAUDE.md](../CLAUDE.md) | Entrada Claude no template |
+| [../AGENTS.md](../AGENTS.md) | Entrada Codex no template |
+| [CURSOR.md](CURSOR.md) | Referência rápida Cursor |
+| [OPTIMIZATION-PLAN.md](OPTIMIZATION-PLAN.md) | Plano de melhorias (tokens, P0–P2) |
+| [OPTIMIZATION-IMPLEMENTATION-TASKS.md](OPTIMIZATION-IMPLEMENTATION-TASKS.md) | Subtarefas para IA implementar o plano |
+| [../.cursor/rules/](../.cursor/rules/) | Fonte completa dos procedimentos |
+
+---
+
+*Índice central — detalhes nos três guias em `platforms/`.*

package/.task-flow/CODEX.md

@@ -0,0 +1,141 @@
+# RBIN Task Flow — Codex workflows
+
+Codex loads **AGENTS.md** at session start (32 KiB default cap). This file holds **full procedures** — read it when the user runs a `task-flow:` command or when AGENTS.md points here.
+
+**Do not paste this entire file into AGENTS.md.**
+
+---
+
+## task-flow: sync
+
+1. Read `.task-flow/tasks.input.txt`, `.internal/tasks.json`, `.internal/status.json`.
+2. Compare tasks by `originalRequest`.
+3. New tasks: generate 3–8 subtasks, `createdAt` ISO, contexts from `.task-flow/contexts/`.
+4. Write/update `tasks.json`, `status.json`, `tasks.status.md` with Summary.
+5. Preserve status on modified tasks when subtasks still align.
+6. Do not populate `tasks.flow.md`.
+
+Sync: `.cursor/rules/task-flow-sync.mdc` · Think: `.cursor/rules/task_analysis.mdc`
+
+---
+
+## task-flow: run next X | run X | run all
+
+See AGENTS.md **Run** section. Prefer `.claude/skills/task-flow-run/workflow.md`; fallback: `.cursor/rules/task_work.mdc`.
+
+**Dependency:** `run N` only if tasks `1..N-1` fully done.
+
+**Per subtask:** implement → `done` in `status.json` → refresh `tasks.status.md` → suggest commit.
+
+**Blocked:** set `in_progress`, explain.
+
+---
+
+## task-flow: status
+
+Display `.task-flow/tasks.status.md`. If missing, run sync first.
+
+---
+
+## task-flow: think
+
+1. Read `tasks.input.txt`.
+2. Scan repo for TODOs, gaps, tests, incomplete features.
+3. Propose new `- task` lines.
+4. **Ask** before appending to `tasks.input.txt`.
+5. If confirmed, append and suggest `task-flow: sync`.
+
+---
+
+## task-flow: check
+
+1. `package.json` scripts: lint fix variant, then `build`.
+2. Fix until pass.
+3. Does not edit task files.
+
+Rule: `.cursor/rules/task_check.mdc`
+
+---
+
+## task-flow: audit
+
+1. Score project vs the checklist in `.cursor/rules/coding_standards.mdc` (not the full doc unless user wants depth).
+2. Present table; ask what to adopt.
+3. Never impose wholesale refactors.
+
+Rule: `.cursor/rules/task_audit.mdc`
+
+---
+
+## task-flow: improve changes
+
+1. `git diff --name-only HEAD` (read-only).
+2. If empty, stop.
+3. Audit only those paths vs coding standards.
+4. Ask before edits.
+
+Rule: `.cursor/rules/task_improve_changes.mdc`
+
+---
+
+## task-flow: review X
+
+1. Load done subtasks for task X from `status.json`.
+2. Verify implementation in codebase.
+3. Report false positives; ask to revert status if needed.
+
+Rule: `.cursor/rules/task_review.mdc`
+
+---
+
+## task-flow: refactor X
+
+Refactor task-related files: no behavior change, remove explanatory comments, keep section separators.
+
+Rule: `.cursor/rules/task_refactor.mdc`
+
+---
+
+## task-flow: estimate X
+
+Read `tasks.json`; one hour range; average developer, average pace, no AI acceleration.
+
+Rule: `.cursor/rules/task_estimate.mdc`
+
+---
+
+## task-flow: report X
+
+Verify task done; write `.task-flow/docs/task-X-implementation.md`.
+
+Rule: `.cursor/rules/task_report.mdc`
+
+---
+
+## task-flow: generate flow
+
+Populate `.task-flow/tasks.flow.md` with deps, hours, model hints (no Opus).
+
+Rule: `.cursor/rules/task_generate_flow.mdc`
+
+---
+
+## Implementing code (any subtask)
+
+Follow the checklist in `.cursor/rules/coding_standards.mdc`. For examples/Nest: read sections of `.task-flow/docs/coding-standards-full.md` only.
+
+---
+
+## Graphify (optional)
+
+Only during `run` / `think` when `graphify-out/` exists. See `.task-flow/GRAPHIFY.md`. Does not replace status updates.
+
+---
+
+## Verify Codex instructions
+
+```bash
+codex --ask-for-approval never "Summarize the project instructions you follow for RBIN Task Flow."
+```
+
+If Task Flow rules missing, check `project_doc_max_bytes` in `.codex/config.toml` (template from `rbin-task-flow init`).