rbin-task-flow 1.25.1 → 1.26.0

package/AGENTS.md

@@ -29,18 +29,13 @@ No explanatory comments. Complex topics → `dev-logs/*.md`. Allowed: `// ──
 | Command | Read first |
 |---------|------------|
 | `task-flow: sync` | Section **Sync** below; details `.task-flow/guides/CODEX.md` |
+| `task-flow: from contexts` | `.cursor/rules/task_from_contexts.mdc` · then `sync` |
 | `task-flow: run …` | Section **Run** below; details `.task-flow/guides/CODEX.md` |
 | `task-flow: status` | `.task-flow/tasks.status.md` |
-| `task-flow: think` | `.task-flow/guides/CODEX.md` · optional codebase scan |
-| `task-flow: check` | `.cursor/rules/task_check.mdc` · `package.json` |
-| `task-flow: improve changes` | `git diff --name-only HEAD` · `.cursor/rules/task_improve_changes.mdc` |
 | `task-flow: audit` | `.cursor/rules/task_audit.mdc` · checklist `coding_standards.mdc` (full: `.task-flow/guides/coding-standards-full.md` if needed) |
-| `task-flow: review X` | `.task-flow/guides/CODEX.md` |
 | `task-flow: validate` | `.cursor/rules/task_validate.mdc` · then sync |
-| `task-flow: refactor X` | `.cursor/rules/task_refactor.mdc` |
-| `task-flow: estimate X` | `.task-flow/guides/CODEX.md` |
+| `task-flow: estimate X` / `X,Y` / `all` | `.cursor/rules/task_estimate.mdc` · `.task-flow/guides/CODEX.md` |
 | `task-flow: report X` | `.task-flow/guides/CODEX.md` |
-| `task-flow: generate flow` | `.cursor/rules/task_generate_flow.mdc` |
 | Implementing code | Checklist `.cursor/rules/coding_standards.mdc` · depth: `.task-flow/guides/coding-standards-full.md` (sections only) |
 
 ## Sync (embedded)
@@ -52,7 +47,6 @@ No explanatory comments. Complex topics → `dev-logs/*.md`. Allowed: `// ──
 5. **Modified:** regen subtasks, **preserve** done/pending where possible.
 6. List `.task-flow/contexts/`; match to tasks; honor `task-flow-screen file.ext`.
 7. `status.json` = truth; sync `tasks.status.md` checkboxes + 📊 Summary.
-8. Do not fill `tasks.flow.md` (only `generate flow`).
 
 ## Run (embedded)
 
@@ -60,7 +54,7 @@ No explanatory comments. Complex topics → `dev-logs/*.md`. Allowed: `// ──
 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 `graphify-out/graph.json` exists, prefer `graphify query` before repo-wide grep.
+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.
 
@@ -74,10 +68,6 @@ Leia AGENTS.md. Execute task-flow: sync.
 Leia AGENTS.md e .task-flow/guides/CODEX.md (Run). task-flow: run next 3.
 ```
 
-```
-task-flow: improve changes — git diff --name-only HEAD, audite só esses arquivos.
-```
-
 ## Other platforms
 
 Claude: `CLAUDE.md` + `.claude/skills/`. Cursor: `.cursor/rules/`. Index: `.task-flow/guides/AI-PLATFORMS.md`.

package/CLAUDE.md

@@ -14,18 +14,13 @@
 | Action | Skill |
 |--------|--------|
 | Sync input → system | `/task-flow-sync` |
+| Draft tasks from `contexts/` | `/task-flow-from-contexts` |
 | Run subtasks | `/task-flow-run` |
 | Status | `/task-flow-status` |
-| Suggest new tasks | `/task-flow-think` |
-| Lint + build | `/task-flow-check` |
 | Audit repo | `/task-flow-audit` |
-| Audit diff only | `/task-flow-improve-changes` |
-| Verify done | `/task-flow-review` |
 | Validate + fill gaps | `/task-flow-validate` |
-| Refactor task code | `/task-flow-refactor` |
-| Estimate hours | `/task-flow-estimate` |
+| Estimate hours (`X`, `X,Y`, `all`) | `/task-flow-estimate` |
 | Implementation report | `/task-flow-report` |
-| tasks.flow.md | `/task-flow-generate-flow` |
 | Implement code | `/rbin-coding-standards` (invoke explicitly; checklist first, full doc sections only if needed) |
 | Commit suggestion | `/rbin-git` |
 
@@ -43,7 +38,7 @@ Natural language `task-flow: …` works the same. Details: [.task-flow/README.md
 
 ## Graphify (optional)
 
-During `/task-flow-run`, if `graphify-out/` exists, use `graphify query` before broad search. See [.task-flow/guides/GRAPHIFY.md](.task-flow/guides/GRAPHIFY.md).
+During `/task-flow-run`, if `.task-flow/guides/graphify-out/` exists, use `graphify query` with `--graph .task-flow/guides/graphify-out/graph.json` before broad search. See [.task-flow/guides/GRAPHIFY.md](.task-flow/guides/GRAPHIFY.md).
 
 ## Cursor rules (reference)
 

package/README.md

@@ -77,10 +77,10 @@ rbin-task-flow init --share-ai-config  # Versiona .cursor/skills/ e .cursor/rule
 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 reset         # Reinstala o Task Flow do zero
-rbin-task-flow reset --graphify  # Reset + graphify extract --backend claude-cli (CLI Graphify no PATH)
+rbin-task-flow update --graphify # Update + grafo em .task-flow/guides/graphify-out/
+rbin-task-flow reset --graphify  # Reset + graphify extract (CLI Graphify no PATH)
 rbin-task-flow version-check # Verifica atualizações de modelos
 rbin-task-flow info          # Mostra informações
-rbin-task-flow check         # Roda lint/fix e build quando existirem
 rbin-task-flow estimate <ids> # Estima tempo (ex: "1" ou "1,2" ou "all")
 rbin-task-flow report <ids>  # Gera relatório (ex: "1" ou "1,2" ou "all")
 ```
@@ -91,34 +91,30 @@ 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):** `rbin-task-flow init --graphify` configura coexistência e roda `graphify extract . --backend claude-cli` (CLI via `rbin-install-dev`; usa assinatura Claude Code).
+**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).
 
-**Claude Code / Cursor skills (v1.20+):** `init` copia 15 skills para `.claude/skills/` e `.cursor/skills/` — use `/task-flow-sync`, `/task-flow-run`, `/task-flow-validate`, etc.
+**Claude Code / Cursor skills (v1.20+):** `init` copia 10 skills para `.claude/skills/` e `.cursor/skills/` — use `/task-flow-from-contexts`, `/task-flow-sync`, `/task-flow-run`, etc.
 
 **Codex (v1.21+):** `AGENTS.md` com sync/run embutidos, `.task-flow/guides/CODEX.md` sob demanda, `.codex/config.toml` (64 KiB).
 
 **Cursor (v1.23+):** `task-flow-cursor.mdc` + `rbin-git-policy.mdc` (2 always-on) + skills — ver `.task-flow/guides/CURSOR.md`.
 
-**Perfil minimal:** `init --profile minimal` instala só as 2 regras always-on e as 15 skills; workflows via `@task-flow-*` (sem `task_work`, `coding_standards` glob, etc.). `standard` (padrão) copia todas as regras `.cursor/rules/`.
+**Perfil minimal:** `init --profile minimal` instala só as 2 regras always-on e as 10 skills; workflows via `@task-flow-*` (sem `task_work`, `coding_standards` glob, etc.). `standard` (padrão) copia todas as regras `.cursor/rules/`.
 
 **Compartilhar com o time:** `init --share-ai-config` não ignora `.cursor/skills/` nem `.cursor/rules/` no `.gitignore` (só `.cursor/settings.json` e overrides locais). Padrão: `.cursor/` inteiro ignorado — menos ruído no repo, config local por dev.
 
 | Comando | Por Que Usar | Feature Principal |
 |---------|--------------|-------------------|
+| `task-flow: from contexts` | **Gera** tasks a partir de specs/mockups | Lê arquivos em `contexts/` (PDF, imagem, texto…) e adiciona linhas em `tasks.input.txt`; depois rode `sync` |
 | `task-flow: sync` | **Sincroniza** tarefas do arquivo texto com o sistema | Mantém tudo sincronizado automaticamente - adiciona novas, remove deletadas, preserva seu progresso |
-| `task-flow: think` | **Descobre** tarefas que você esqueceu | Analisa código e sugere tarefas que faltam (testes, refatoração, documentação) |
 | `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: check` | **Valida** lint e build antes de revisar ou commitar | Roda lint com fix quando disponível e depois build, corrigindo problemas do projeto atual |
-| `task-flow: improve changes` | **Audita** só o diff atual | Faz o mesmo audit de padrões, mas restrito aos arquivos alterados em relação ao `HEAD` |
 | `task-flow: status` | **Visualiza** o progresso rapidamente | Vê resumo com tasks completas, em andamento e quantas subtarefas faltam |
 | `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 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 |
-| `task-flow: review X` | **Garante** qualidade do trabalho | Verifica tarefas específicas (ex: `task-flow: review 1` ou `task-flow: review 10,11` ou `task-flow: review all`) |
 | `task-flow: validate` | **Valida** implementação e **preenche lacunas** | Auditoria profunda: reverifica done/pending, corrige status falso, adiciona lacunas em `tasks.input.txt` e faz sync |
-| `task-flow: refactor X` | **Melhora** código sem quebrar | Refatora tarefas específicas (ex: `task-flow: refactor 1` ou `task-flow: refactor 10,11` ou `task-flow: refactor all`) |
-| `task-flow: estimate X` | **Estima** tempo para gestão | Calcula estimativa de tempo (ex: `task-flow: estimate 1` ou `task-flow: estimate 10,11`) |
+| `task-flow: estimate X` | **Estima** tempo para gestão | `estimate 1`, `estimate 10,11` ou `estimate all` |
 | `task-flow: report X` | **Documenta** implementação | Gera relatório detalhado (ex: `task-flow: report 1` ou `task-flow: report 10,11`) |
 
 **Fluxo típico:**
@@ -463,10 +459,10 @@ rbin-task-flow init --share-ai-config  # Commit .cursor/skills and rules with th
 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 reset         # Reinstall Task Flow from scratch
-rbin-task-flow reset --graphify  # Reset + graphify extract --backend claude-cli (Graphify CLI on PATH)
+rbin-task-flow update --graphify # Update + graph at .task-flow/guides/graphify-out/
+rbin-task-flow reset --graphify  # Reset + graphify extract (Graphify CLI on PATH)
 rbin-task-flow version-check # Check for model updates
 rbin-task-flow info          # Show information
-rbin-task-flow check         # Run lint/fix and build when available
 rbin-task-flow estimate <ids> # Estimate time (e.g., "1" or "1,2" or "all")
 rbin-task-flow report <ids>   # Generate report (e.g., "1" or "1,2" or "all")
 ```
@@ -477,13 +473,13 @@ 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):** `rbin-task-flow init --graphify` — cooperative setup + runs `graphify extract . --backend claude-cli` (CLI from `rbin-install-dev`; uses Claude Code subscription).
+**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).
 
-**Claude / Cursor skills (v1.20+):** installs 15 skills — use `/task-flow-sync`, `/task-flow-run`, `/task-flow-validate`, etc.
+**Claude / Cursor skills (v1.20+):** installs 10 skills — use `/task-flow-from-contexts`, `/task-flow-sync`, `/task-flow-run`, etc.
 
 **Codex (v1.21+):** optimized `AGENTS.md`, `.task-flow/guides/CODEX.md`, `.codex/config.toml`.
 
-**Cursor (v1.23+):** 2 always-on rules + 15 skills — `@task-flow-sync`, `@task-flow-run`, `@task-flow-validate`.
+**Cursor (v1.23+):** 2 always-on rules + 10 skills — `@task-flow-from-contexts`, `@task-flow-sync`, `@task-flow-run`.
 
 **Minimal profile:** `init --profile minimal` copies only `task-flow-cursor.mdc` and `rbin-git-policy.mdc` plus skills; use `@task-flow-*` for workflows. `standard` (default) copies all rules under `.cursor/rules/`.
 
@@ -491,20 +487,16 @@ After initializing, use these commands in your AI (Cursor/Claude/Codex) to autom
 
 | Command | Why Use It | Key Feature |
 |---------|------------|-------------|
+| `task-flow: from contexts` | **Draft** tasks from specs/mockups | Reads `contexts/` files (PDF, image, text…) and appends lines to `tasks.input.txt`; then run `sync` |
 | `task-flow: sync` | **Sync** tasks from text file with system | Keeps everything synchronized automatically - adds new, removes deleted, preserves your progress |
-| `task-flow: think` | **Discover** tasks you forgot | Analyzes code and suggests missing tasks (tests, refactoring, documentation) |
 | `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: check` | **Validate** lint and build before review or commit | Runs lint with autofix when available and then build, fixing current-project issues first |
-| `task-flow: improve changes` | **Audit** only the current diff | Runs the same standards audit, but restricted to files changed relative to `HEAD` |
 | `task-flow: status` | **Visualize** progress quickly | See summary with completed tasks, in progress, and remaining subtasks |
 | `task-flow: run next X` | **Automate** work on next subtasks | AI works on next X subtasks sequentially, you just follow along |
 | `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 |
-| `task-flow: review X` | **Ensure** work quality | Verifies specific tasks (e.g., `task-flow: review 1` or `task-flow: review 10,11` or `task-flow: review all`) |
 | `task-flow: validate` | **Validate** implementation and **fill gaps** | Deep audit: recheck done/pending, fix false done, append gaps to `tasks.input.txt`, then sync |
-| `task-flow: refactor X` | **Improve** code without breaking | Refactors specific tasks (e.g., `task-flow: refactor 1` or `task-flow: refactor 10,11` or `task-flow: refactor all`) |
-| `task-flow: estimate X` | **Estimate** time for management | Calculates time estimate (e.g., `task-flow: estimate 1` or `task-flow: estimate 10,11`) |
+| `task-flow: estimate X` | **Estimate** time for management | `estimate 1`, `estimate 10,11`, or `estimate all` |
 | `task-flow: report X` | **Document** implementation | Generates detailed report (e.g., `task-flow: report 1` or `task-flow: report 10,11`) |
 
 **Typical workflow:**

package/bin/cli.js

@@ -7,8 +7,6 @@ const { parseProfileOption } = require('../lib/profiles');
 const { checkVersionUpdates } = require('../lib/version');
 const { estimateTask } = require('../lib/estimate');
 const { generateReport } = require('../lib/report');
-const { runAudit } = require('../lib/audit');
-const { runCheck } = require('../lib/check');
 const chalk = require('chalk');
 
 program
@@ -21,7 +19,7 @@ function addInstallCommand(name, description, extra = {}) {
     .command(name)
     .description(description)
     .option('-p, --path <path>', 'Target directory (default: current directory)')
-    .option('-g, --graphify', 'Run graphify extract . --backend claude-cli after install (requires graphify CLI)')
+    .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'
@@ -80,24 +78,6 @@ program
     await generateReport(taskIds, targetPath);
   });
 
-program
-  .command('audit')
-  .description('List files with unstaged changes (not yet git add)')
-  .option('-p, --path <path>', 'Target directory (default: current directory)')
-  .action(async (options) => {
-    const targetPath = options.path || process.cwd();
-    await runAudit(targetPath);
-  });
-
-program
-  .command('check')
-  .description('Run lint fix when available, then build')
-  .option('-p, --path <path>', 'Target directory (default: current directory)')
-  .action(async (options) => {
-    const targetPath = options.path || process.cwd();
-    await runCheck(targetPath);
-  });
-
 program
   .command('info')
   .description('Show information about RBIN Task Flow')
@@ -119,9 +99,8 @@ program
     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")');
-    console.log(chalk.cyan('  rbin-task-flow check') + '       - Run lint fix and build when available');
-    console.log(chalk.cyan('  rbin-task-flow audit') + '       - List unstaged files (not yet git add)');
-    console.log(chalk.cyan('  rbin-task-flow info') + '         - Show this information\n');
+    console.log(chalk.cyan('  rbin-task-flow info') + '         - Show this information');
+    console.log(chalk.gray('  task-flow: audit — use in AI (@task-flow-audit)\n'));
   });
 
 program.parse();

package/lib/gitignore.js

@@ -8,7 +8,6 @@ const ENTRIES_DEFAULT = [
   '.claude/',
   '.cursor/',
   '.task-flow/',
-  'graphify-out/',
   'CLAUDE.md',
   'AGENTS.md',
 ];
@@ -18,7 +17,6 @@ const ENTRIES_SHARE_AI_CONFIG = [
   '.cursor/settings.json',
   '.cursor/rules/*.local.mdc',
   '.task-flow/',
-  'graphify-out/',
   'CLAUDE.md',
   'AGENTS.md',
 ];

package/lib/graphify.js

@@ -3,10 +3,14 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const { showSuccess, showWarning, showInfo } = require('./utils');
 
-const GRAPHIFY_OUT = 'graphify-out/';
+const GRAPHIFY_GUIDES_DIR = '.task-flow/guides';
+const GRAPHIFY_OUT_REL = `${GRAPHIFY_GUIDES_DIR}/graphify-out`;
+const GRAPHIFY_GRAPH_JSON = `${GRAPHIFY_OUT_REL}/graph.json`;
+const GRAPHIFY_GRAPH_FLAG = `--graph ${GRAPHIFY_GRAPH_JSON}`;
+const LEGACY_GRAPHIFY_OUT = 'graphify-out';
 const UPSTREAM_GRAPHIFY_RULE = 'graphify.mdc';
-const GRAPHIFY_EXTRACT_CMD = 'graphify extract . --backend claude-cli';
-const GRAPHIFY_EXTRACT_ARGS = ['extract', '.', '--backend', 'claude-cli'];
+const GRAPHIFY_EXTRACT_CMD = `graphify extract . --backend claude-cli --out ${GRAPHIFY_GUIDES_DIR}`;
+const GRAPHIFY_EXTRACT_ARGS = ['extract', '.', '--backend', 'claude-cli', '--out', GRAPHIFY_GUIDES_DIR];
 
 function graphifyCliAvailable() {
   const result = spawnSync('graphify', ['--help'], {
@@ -44,25 +48,42 @@ function demoteUpstreamGraphifyRule(targetPath) {
   return true;
 }
 
-function ensureGraphifyGitignore(targetPath) {
+function stripLegacyGraphifyGitignore(targetPath) {
   const gitignorePath = path.join(targetPath, '.gitignore');
   if (!fs.existsSync(gitignorePath)) {
     return false;
   }
 
   let content = fs.readFileSync(gitignorePath, 'utf8');
-  const entry = GRAPHIFY_OUT.replace(/\/$/, '');
-  const linePattern = new RegExp(`^${entry}\\/?$`, 'm');
+  const before = content;
+  const linePattern = new RegExp(`^${LEGACY_GRAPHIFY_OUT}\\/?\\s*$`, 'gm');
+  content = content.replace(linePattern, '');
 
-  if (linePattern.test(content)) {
+  if (content === before) {
     return false;
   }
 
-  if (!content.endsWith('\n')) {
-    content += '\n';
+  fs.writeFileSync(gitignorePath, content.replace(/\n{3,}/g, '\n\n'));
+  return true;
+}
+
+async function migrateLegacyGraphifyOut(targetPath) {
+  await fs.ensureDir(path.join(targetPath, GRAPHIFY_GUIDES_DIR));
+
+  const legacyDir = path.join(targetPath, LEGACY_GRAPHIFY_OUT);
+  const guidesOutDir = path.join(targetPath, GRAPHIFY_OUT_REL);
+
+  if (!fs.existsSync(legacyDir)) {
+    return false;
   }
-  content += `\n${entry}/\n`;
-  fs.writeFileSync(gitignorePath, content);
+
+  if (fs.existsSync(guidesOutDir)) {
+    showInfo(`Legacy ${LEGACY_GRAPHIFY_OUT}/ kept — ${GRAPHIFY_OUT_REL}/ already exists`);
+    return false;
+  }
+
+  await fs.move(legacyDir, guidesOutDir);
+  showSuccess(`Graphify output moved: ${LEGACY_GRAPHIFY_OUT}/ → ${GRAPHIFY_OUT_REL}/`);
   return true;
 }
 
@@ -72,6 +93,8 @@ function runGraphifyExtract(targetPath) {
     return false;
   }
 
+  fs.ensureDirSync(path.join(targetPath, GRAPHIFY_GUIDES_DIR));
+
   showInfo(`Running ${GRAPHIFY_EXTRACT_CMD} (may take a few minutes)...`);
   const result = spawnSync('graphify', GRAPHIFY_EXTRACT_ARGS, {
     cwd: targetPath,
@@ -84,7 +107,7 @@ function runGraphifyExtract(targetPath) {
     return false;
   }
 
-  showSuccess('Graphify knowledge graph (graphify-out/)');
+  showSuccess(`Graphify knowledge graph (${GRAPHIFY_OUT_REL}/)`);
   return true;
 }
 
@@ -94,29 +117,38 @@ async function setupGraphifyIntegration(targetPath, options = {}) {
     showSuccess('Graphify upstream rule demoted (alwaysApply: false) — Task Flow keeps priority');
   }
 
-  const gitignoreUpdated = ensureGraphifyGitignore(targetPath);
-  if (gitignoreUpdated) {
-    showSuccess('graphify-out/ added to .gitignore');
+  await migrateLegacyGraphifyOut(targetPath);
+
+  const gitignoreCleaned = stripLegacyGraphifyGitignore(targetPath);
+  if (gitignoreCleaned) {
+    showInfo('Removed legacy graphify-out/ from .gitignore (graph lives under .task-flow/guides/)');
   }
 
+  await fs.ensureDir(path.join(targetPath, GRAPHIFY_GUIDES_DIR));
+
   if (options.extract) {
     runGraphifyExtract(targetPath);
   } else if (graphifyCliAvailable()) {
-    const graphJson = path.join(targetPath, 'graphify-out', 'graph.json');
+    const graphJson = path.join(targetPath, GRAPHIFY_GRAPH_JSON);
     if (!fs.existsSync(graphJson)) {
       showInfo(`Graphify CLI detected — run: ${GRAPHIFY_EXTRACT_CMD}  (or: rbin-task-flow init --graphify)`);
     }
   }
 
-  showInfo('Graphify + Task Flow guide: .task-flow/guides/GRAPHIFY.md');
+  showInfo(`Graphify + Task Flow guide: .task-flow/guides/GRAPHIFY.md (output: ${GRAPHIFY_OUT_REL}/)`);
 }
 
 module.exports = {
   setupGraphifyIntegration,
   demoteUpstreamGraphifyRule,
-  ensureGraphifyGitignore,
+  stripLegacyGraphifyGitignore,
+  migrateLegacyGraphifyOut,
   runGraphifyExtract,
   graphifyCliAvailable,
   GRAPHIFY_EXTRACT_CMD,
   GRAPHIFY_EXTRACT_ARGS,
+  GRAPHIFY_GUIDES_DIR,
+  GRAPHIFY_OUT_REL,
+  GRAPHIFY_GRAPH_JSON,
+  GRAPHIFY_GRAPH_FLAG,
 };

package/lib/install.js

@@ -269,7 +269,6 @@ async function copyTaskFlow(targetPath, options = {}) {
   const PRESERVED_ON_INIT = [
     path.join(taskFlowDest, 'tasks.input.txt'),
     path.join(taskFlowDest, 'tasks.status.md'),
-    path.join(taskFlowDest, 'tasks.flow.md'),
     path.join(taskFlowDest, 'install-meta.json'),
   ];
 
@@ -296,25 +295,13 @@ async function copyTaskFlow(targetPath, options = {}) {
   await fs.ensureDir(path.join(taskFlowDest, 'guides', 'reports'));
   await migrateLegacyTaskFlowLayout(taskFlowDest);
 
-  const flowPath = path.join(taskFlowDest, 'tasks.flow.md');
-  if (!fs.existsSync(flowPath)) {
-    const flowStub = [
-      '# Task Flow — Dependencies, Hours & Model Recommendations',
-      '',
-      '<!-- Populated by task-flow: generate flow. Do not edit manually. -->',
-      '<!-- Horas: uso para cobrança ao cliente -->',
-      '',
-    ].join('\n');
-    await fs.writeFile(flowPath, flowStub);
-  }
-
   showSuccess('Task Flow directory');
   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, tasks.flow.md');
+    showInfo('Protected on init: .internal/, tasks.input.txt, tasks.status.md');
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbin-task-flow",
-  "version": "1.25.1",
+  "version": "1.26.0",
   "description": "AI-powered task management for Claude and Cursor",
   "main": "index.js",
   "bin": {
@@ -20,7 +20,6 @@
     "cli",
     "task-management",
     "ai-powered",
-    "generate-flow",
     "tasks-flow"
   ],
   "author": "Rubens de Oliveira",

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

@@ -1,15 +0,0 @@
----
-name: task-flow-check
-description: Runs project lint fix and build from package.json until passing. Use when the user says task-flow check, run lint and build, or validate project before commit.
-disable-model-invocation: true
----
-
-# Task Flow — Check
-
-1. Read `package.json` scripts.
-2. Run lint with fix variant if present (`lint:fix`, `lint-fix`, or `lint -- --fix`); fix issues.
-3. Run `build` if defined; fix failures.
-4. Re-run until both pass.
-5. Report what ran and final status.
-
-Does not change task files. Reference: `.cursor/rules/task_check.mdc`

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

@@ -1,15 +0,0 @@
----
-name: task-flow-generate-flow
-description: Populates tasks.flow.md with dependencies, billing hours, and model recommendations for RBIN Task Flow tasks. Use when the user says task-flow generate flow, gerar flow, or tasks flow dependencies.
-disable-model-invocation: true
-paths: [".task-flow/**"]
----
-
-# Task Flow — Generate flow
-
-1. Read `.task-flow/.internal/tasks.json` and optional `status.json`.
-2. For each task: dependencies, hour range (billing), 3 models (GPT-5.x, Composer, Claude Haiku/Sonnet only — **never Opus**).
-3. Write `.task-flow/tasks.flow.md` (overwrite populated sections).
-4. Use AI judgment for model order and effort per task.
-
-Reference: `.cursor/rules/task_generate_flow.mdc`

package/.claude/skills/task-flow-improve-changes/SKILL.md

@@ -1,15 +0,0 @@
----
-name: task-flow-improve-changes
-description: Audits only uncommitted files against coding standards. Use when the user says task-flow improve changes, audit my diff, or check uncommitted changes against standards.
-disable-model-invocation: true
----
-
-# Task Flow — Improve changes
-
-1. Run `git diff --name-only HEAD` (read-only git).
-2. If empty, stop — no uncommitted changes.
-3. Audit **only** those paths using the same checklist as audit (`.cursor/rules/coding_standards.mdc`). Full reference: `.task-flow/guides/coding-standards-full.md` — relevant sections only if a category needs depth.
-4. Present findings; ask what to fix.
-5. Does **not** run lint/build — use `/task-flow-check` separately.
-
-Reference: `.cursor/rules/task_improve_changes.mdc`

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

@@ -1,14 +0,0 @@
----
-name: task-flow-refactor
-description: Refactors code for task X without changing behavior; removes explanatory comments. Use when the user says task-flow refactor X or refactor completed task code.
-disable-model-invocation: true
----
-
-# Task Flow — Refactor
-
-1. Identify files related to task X (from implementation scope).
-2. Remove explanatory comments; keep only `// ────────────────────────────────` section separators.
-3. Improve names/structure; **no** behavior change.
-4. Never run git write commands.
-
-Reference: `.cursor/rules/task_refactor.mdc`, `.cursor/rules/code_comments.mdc`

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

@@ -1,14 +0,0 @@
----
-name: task-flow-review
-description: Verifies completed RBIN Task Flow tasks are actually implemented in the codebase. Use when the user says task-flow review X, review task 1, or verify done tasks.
-disable-model-invocation: true
----
-
-# Task Flow — Review
-
-1. Read `tasks.json`, `status.json` for task ID(s) X or `all`.
-2. For each subtask marked `done`: verify files/code/tests exist and match requirements.
-3. Report ✅ correct vs ⚠️ falsely marked done.
-4. Ask if user wants status reverted to `pending` / `in_progress`.
-
-Reference: `.cursor/rules/task_review.mdc`

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

@@ -1,19 +0,0 @@
----
-name: task-flow-think
-description: Analyzes the codebase and suggests new lines for tasks.input.txt without adding them automatically. Use when the user says task-flow think, suggest tasks, analise tasks novas, or check for missing tasks.
-disable-model-invocation: true
----
-
-# Task Flow — Think
-
-1. Read `.task-flow/tasks.input.txt` (existing plan).
-2. Scan codebase: TODOs, missing tests, half-done features, security/perf gaps.
-3. Propose new tasks as `- Description` lines (RBIN format).
-4. **Ask** user before writing to `tasks.input.txt`.
-5. If user confirms, append only new lines; then suggest `/task-flow-sync`.
-
-Optional: `graphify query` on large repos before suggesting.
-
-For deep verify + auto-add lacunas (no ask): `@task-flow-validate` (`task-flow: validate`).
-
-Reference: `.cursor/rules/task_analysis.mdc` · Sync after confirm: `@task-flow-sync`

package/.cursor/rules/task_analysis.mdc

@@ -1,45 +0,0 @@
----
-description: Suggests new tasks for tasks.input.txt via task-flow think. Use for think, suggest tasks, analyze codebase for missing tasks — not for sync (use task-flow-sync.mdc).
-alwaysApply: false
----
-
-# task-flow: think
-
-**Not sync.** For `task-flow: sync` use [task-flow-sync.mdc](mdc:.cursor/rules/task-flow-sync.mdc) or `@task-flow-sync`.
-
-**Not validate.** For deep verify + auto-add lacunas use [task_validate.mdc](mdc:.cursor/rules/task_validate.mdc) or `@task-flow-validate`.
-
-**Prefer:** `@task-flow-think` · After user adds lines: `@task-flow-sync`
-
-## When to run
-
-User says `task-flow: think`, `suggest tasks`, `check for new tasks`, `analyze codebase for tasks`, etc.
-
-## Process
-
-1. Read `.task-flow/tasks.input.txt` (existing planned tasks)
-2. Scan codebase for gaps: TODO/FIXME, missing tests, incomplete features, docs, security, performance, error handling
-3. Propose **specific** lines: `- Task description` (no `[ ]`)
-4. **Ask** before adding to `tasks.input.txt` — never auto-add
-5. If user confirms: append only; do not remove or edit existing lines
-6. Suggest `task-flow: sync` after input changes
-
-## Output format
-
-```markdown
-## Suggested Tasks for tasks.input.txt
-
-- Add unit tests for UserService
-- Implement error handling in API endpoints
-```
-
-## Optional roadmap
-
-For package improvements see [.task-flow/guides/OPTIMIZATION-PLAN.md](mdc:.task-flow/guides/OPTIMIZATION-PLAN.md) — not part of think unless user asks.
-
-## Integration
-
-- [task-flow-sync.mdc](mdc:.cursor/rules/task-flow-sync.mdc) after new tasks are added
-- [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc) — never commit automatically
-
-**Principle:** Suggest actionable tasks; user decides what enters `tasks.input.txt`.

package/.cursor/rules/task_check.mdc

@@ -1,37 +0,0 @@
----
-description: Runs lint fix and build for task-flow check until project passes.
-alwaysApply: false
----
-
-# task-flow: check
-
-When the user runs `task-flow: check`:
-
-1. **Detect project scripts**: Read `package.json` and look for lint and build scripts.
-2. **Run lint first**: Prefer a fix-capable lint command if present (`lint:fix`, `lint-fix`, or equivalent). If there is only `lint`, run it and fix the reported issues.
-3. **Run build next**: If a `build` script exists, run it after lint succeeds.
-4. **Fix failures**: If lint or build fails, fix the issues and re-run until they pass.
-5. **Keep scope local**: This command is only for project checks. It does not run the coding-standards audit and does not change task files by itself.
-
----
-
-## How to execute
-
-- **Step 1**: Read `package.json` and identify which package manager and scripts the project uses.
-- **Step 2**: Run lint first, preferring an autofix variant when one exists.
-- **Step 3**: Fix any lint errors or warnings that should be resolved now.
-- **Step 4**: Run build and fix any failures.
-- **Step 5**: Report what ran, what was skipped, and whether the project is passing.
-
----
-
-## Natural language
-
-- **FAST FORMAT**: `task-flow: check` or `task-flow check`
-- "run checks", "run lint and build", "validate this project" → same command
-
----
-
-## Principle
-
-> **Use `task-flow: check` to make the current project pass its local validation steps before reviewing or committing changes.**