@brunosps00/dev-workflow 0.8.1 → 0.9.0

package/README.md

@@ -19,7 +19,7 @@ This will:
 
 > **Compozy-inspired disciplines.** Since 0.5.0, dev-workflow bundles three primitives — `dw-verify`, `dw-memory`, `dw-review-rigor` — adapted from the [Compozy](https://github.com/compozy/compozy) project and invoked internally by existing commands. See [docs/compozy-integration.md](docs/compozy-integration.md) for what was ported and what was not.
 
-Optional dependencies (Playwright browsers, react-doctor, GSD):
+Optional dependencies (Playwright browsers, react-doctor, Trivy, Docker):
 ```bash
 npx @brunosps00/dev-workflow install-deps
 ```
@@ -32,7 +32,7 @@ npx @brunosps00/dev-workflow install-deps
 Facilitates structured ideation before opening a PRD or implementation. Explores multiple directions — conservative, balanced, and bold — with trade-offs for each, then converges on concrete next steps. **Product-aware**: when PRDs or rules exist, automatically reads them to produce a Feature Inventory and tags each option as `[IMPROVES: <feature>]`, `[CONSOLIDATES: <A>+<B>]`, or `[NEW]`. With optional `--onepager` flag, generates a durable one-pager at `.dw/spec/ideas/<slug>.md` that `/dw-create-prd` can consume to reduce clarification questions. Inspired by [`addyosmani/agent-skills@idea-refine`](https://skills.sh/addyosmani/agent-skills/idea-refine), adapted to product-level (features) rather than code-level grounding. No code is written or project files modified by the brainstorm itself.
 
 #### `/dw-autopilot`
-Full pipeline orchestrator that takes a wish and automatically runs the entire development flow: codebase intelligence, research (conditional), brainstorm, PRD, techspec, tasks, execution, QA, review, and commit. Stops at 3 gates: PRD approval, tasks approval, and PR confirmation. With GSD installed, leverages plan verification and parallel execution.
+Full pipeline orchestrator that takes a wish and automatically runs the entire development flow: codebase intelligence (`/dw-map-codebase` + `/dw-intel`), research (conditional), brainstorm, PRD, techspec, tasks, execution (with `/dw-plan-checker` gate and `/dw-execute-phase` wave-based parallel dispatch), QA, review, and commit. Stops at 3 gates: PRD approval, tasks approval, and PR confirmation.
 
 #### `/dw-create-prd`
 Creates a Product Requirements Document by first asking at least 7 clarification questions to fully understand the feature. Generates a structured PRD with numbered functional requirements focused on what and why, saved to `.dw/spec/prd-[feature-name]/prd.md`.
@@ -49,7 +49,7 @@ Breaks down the PRD and TechSpec into implementable tasks with a target of ~6 ta
 Executes a single task from the task list, implementing code that follows project patterns and includes mandatory unit tests. Performs Level 1 validation (acceptance criteria + tests + standards check) and creates a commit upon completion.
 
 #### `/dw-run-plan`
-Executes all pending tasks sequentially and automatically, with Level 1 validation after each task. After all tasks are complete, performs a final Level 2 review (PRD compliance) with an interactive corrections cycle until no gaps remain or the user accepts pending items. With GSD installed, supports plan verification gates and wave-based parallel execution for independent tasks.
+Executes all pending tasks via `/dw-execute-phase`, which gates on `/dw-plan-checker` (6-dimension goal-backward verification) before any code is touched. Wave-based parallel dispatch for independent tasks; atomic commit per task; deviation handling. After all tasks complete, performs a final Level 2 review (PRD compliance) with an interactive corrections cycle until no gaps remain or the user accepts pending items.
 
 #### `/dw-bugfix`
 Analyzes and fixes bugs with automatic triage that distinguishes between bugs, feature requests, and excessive scope. Asks exactly 3 clarification questions before proposing a solution. Supports Direct mode (executes fix immediately) and Analysis mode (`--analysis`) that generates a document for the techspec/tasks pipeline.
@@ -112,13 +112,13 @@ Records an Architecture Decision Record (ADR) for a non-trivial decision during
 ### Intelligence
 
 #### `/dw-resume`
-Restores context from the last session by reading pending tasks, recent git history, and active branches. Suggests the next command to execute. With GSD installed, also restores cross-session state from `.planning/STATE.md`.
+Restores context from the last session by reading `.dw/spec/active-session.md` (written by `/dw-execute-phase` at checkpoint), pending tasks, recent git history, and active branches. Suggests the next command to execute.
 
 #### `/dw-intel`
-Queries codebase intelligence to answer questions about patterns, conventions, and architecture. Uses `.planning/intel/` (if GSD) or `.dw/rules/` as knowledge sources, complemented with direct codebase search. Always cites sources with file paths and line numbers.
+Queries codebase intelligence to answer questions about patterns, conventions, and architecture. Reads `.dw/intel/` (built by `/dw-map-codebase`) as primary source, falls back to `.dw/rules/` and direct grep when absent. Surfaces stale-index warnings (>7 days). Always cites sources with file paths and line numbers.
 
 #### `/dw-analyze-project`
-Scans the repository to identify tech stack, architectural patterns, naming conventions, and anti-patterns. Generates structured documentation in `.dw/rules/` with a project overview (`index.md`) and per-module rule files containing real code examples. With GSD installed, also creates a queryable index in `.planning/intel/`.
+Scans the repository to identify tech stack, architectural patterns, naming conventions, and anti-patterns. Generates structured documentation in `.dw/rules/` with a project overview (`index.md`) and per-module rule files containing real code examples. Also invokes `/dw-map-codebase` to build the queryable index in `.dw/intel/` (the two are complementary — rules are human-readable, intel is machine-queryable).
 
 #### `/dw-deep-research`
 Conducts multi-source research with citation tracking and verification across quick, standard, deep, and ultradeep modes. Executes parallel information gathering, triangulation, and cross-reference verification through 8+ phases, producing a professional report with complete bibliography.
@@ -149,7 +149,7 @@ Discovers skills from the open agent skills ecosystem (`npx skills` / [skills.sh
                             |
                         /dw-run-task (one at a time)
                             |       or
-                        /dw-run-plan (all tasks — parallel with GSD)
+                        /dw-run-plan (all tasks — wave-based parallel native)
                             |
                         /dw-run-qa  -->  .dw/spec/prd-{name}/QA/
                             |
@@ -193,8 +193,7 @@ your-project/
 │   ├── skills/            # Claude Code wrappers
 │   └── settings.json      # MCP servers (Context7, Playwright)
 ├── .agents/skills/        # Codex/Copilot wrappers + bundled skills
-├── .opencode/commands/    # OpenCode wrappers
-└── .planning/             # GSD state (if installed via install-deps)
+└── .opencode/commands/    # OpenCode wrappers
 ```
 
 ## Bundled Skills
@@ -232,8 +231,8 @@ Installed via `npx @brunosps00/dev-workflow install-deps`:
 | **Playwright** | Browser automation for QA, E2E tests, and visual validation | [playwright.dev](https://playwright.dev/) |
 | **Context7 MCP** | Contextual documentation lookup for AI assistants | [upstash/context7-mcp](https://github.com/upstash/context7-mcp) |
 | **react-doctor** | Health score and diagnostics for React projects | [react.doctor](https://www.react.doctor/) |
-| **GSD (get-shit-done-cc)** | Optional engine: parallel execution, plan verification, codebase intelligence, cross-session persistence | [gsd-build/get-shit-done](https://github.com/gsd-build/get-shit-done) |
 | **Trivy** | Native binary scanner used by `/dw-security-check` for CVE, secret, and IaC scanning. `install-deps` detects presence and prints OS-specific install instructions (brew / curl script / choco / Docker) — does not install automatically. | [aquasecurity.github.io/trivy](https://aquasecurity.github.io/trivy/) |
+| **Docker + Docker Compose** | Required by `/dw-new-project` and `/dw-dockerize` for dev dependency seeding and image generation. `install-deps` detects presence and prints OS-specific install instructions — does not install automatically. | [docs.docker.com](https://docs.docker.com/engine/install/) |
 
 ## Options
 
@@ -243,7 +242,7 @@ npx @brunosps00/dev-workflow init --lang=en        # English, skip prompt
 npx @brunosps00/dev-workflow init --lang=pt-br     # Portuguese, skip prompt
 npx @brunosps00/dev-workflow init --force          # Overwrite existing files
 npx @brunosps00/dev-workflow update                # Update commands/templates only
-npx @brunosps00/dev-workflow install-deps          # Install Playwright, react-doctor, GSD
+npx @brunosps00/dev-workflow install-deps          # Install Playwright, react-doctor; check Trivy, Docker
 npx @brunosps00/dev-workflow help                  # Show help
 ```
 
@@ -254,7 +253,12 @@ After running `npx @brunosps00/dev-workflow init`:
 1. **Run `/dw-analyze-project`** in your AI assistant to generate project rules
 2. **Run `/dw-brainstorm`** to start planning a new feature
 3. **Run `/dw-help`** to see all available commands and workflows
-4. **(Optional) Run `npx @brunosps00/dev-workflow install-deps`** for Playwright, react-doctor, and GSD
+4. **(Optional) Run `npx @brunosps00/dev-workflow install-deps`** to install Playwright + react-doctor and check Trivy + Docker
+5. **Run `/dw-map-codebase`** once your project has source files to build the queryable index in `.dw/intel/`
+
+## Acknowledgements
+
+Codebase intelligence (`/dw-intel`, `/dw-map-codebase`, the `dw-codebase-intel` bundled skill) and phase execution patterns (`/dw-execute-phase`, `/dw-plan-checker`, the `dw-execute-phase` bundled skill) were adapted from [`get-shit-done-cc`](https://github.com/gsd-build/get-shit-done) by gsd-build (MIT). Schemas (`stack.json`, `files.json`, `apis.json`, `deps.json`, `arch.md`), the goal-backward verification protocol, and the wave-based parallel execution pattern come from there. dev-workflow specifics: `.dw/` namespace instead of `.planning/`, agent-driven runtime instead of `gsd-sdk` CLI, integration with the rest of the `dw-*` command surface.
 
 ## License
 

package/bin/dev-workflow.js

@@ -30,7 +30,7 @@ const HELP_TEXT = `
                    Preserves: .dw/rules/, .dw/spec/, user data
     install-deps   Install system dependencies (Playwright browsers, MCP servers)
     uninstall      Remove all managed files (commands, templates, wrappers, skills, MCPs)
-                   Preserves: .dw/rules/, .dw/spec/, .planning/ (user data)
+                   Preserves: .dw/rules/, .dw/spec/, .dw/intel/ (user data)
     help           Show this help message
 
   Options:

package/lib/constants.js

@@ -13,13 +13,16 @@ const COMMANDS = {
     { name: 'dw-deep-research', description: 'Researches a topic across sources, tracks citations, and flags claims that don\'t check out.' },
     { name: 'dw-deps-audit', description: 'Finds outdated and supply-chain-compromised packages, drafts a per-package update plan, and runs scoped QA after each upgrade.' },
     { name: 'dw-dockerize', description: 'Reads a project, detects the stack and runtime deps, then proposes Dockerfile and docker-compose for dev and prod with explicit trade-offs.' },
+    { name: 'dw-execute-phase', description: 'Executes a PRD phase in waves with atomic commits per task, deviation handling, and a hard plan-checker gate before any code is touched.' },
     { name: 'dw-find-skills', description: 'Searches the npx skills ecosystem for a skill matching what you need, vets it, and installs it where you choose.' },
     { name: 'dw-fix-qa', description: 'Fixes bugs found in QA and retests them with screenshot evidence until they stay fixed.' },
     { name: 'dw-functional-doc', description: 'Maps screens and user flows into a functional doc, validated end-to-end with Playwright.' },
     { name: 'dw-generate-pr', description: 'Pushes the branch and opens a PR with a body that explains what changed and how to test it.' },
     { name: 'dw-help', description: 'Lists every command and the flows that connect them. Pass a keyword for a contextual shortcut.' },
-    { name: 'dw-intel', description: 'Answers questions about the codebase using its own rules and intel as the source of truth.' },
+    { name: 'dw-intel', description: 'Answers questions about the codebase by querying .dw/intel/ (built by /dw-map-codebase) with .dw/rules/ and grep as fallbacks.' },
+    { name: 'dw-map-codebase', description: 'Builds a queryable index in .dw/intel/ (stack, files, apis, deps, arch) so other commands stop re-exploring the codebase.' },
     { name: 'dw-new-project', description: 'Interviews you about stack and infra, then scaffolds a working monorepo with docker-compose for dev, .env, scripts, CI, and seeded rules.' },
+    { name: 'dw-plan-checker', description: 'Goal-backward verification of a phase tasks.md before execution. Returns PASS, REVISE, or BLOCK across 6 dimensions.' },
     { name: 'dw-quick', description: 'Runs a small, well-defined change with workflow guarantees, no PRD needed.' },
     { name: 'dw-redesign-ui', description: 'Audits a frontend page, proposes design directions you choose from, then ships the redesign.' },
     { name: 'dw-refactoring-analysis', description: 'Catalogs code smells in Fowler\'s vocabulary and ranks them by impact, P0 to P3.' },
@@ -46,13 +49,16 @@ const COMMANDS = {
     { name: 'dw-deep-research', description: 'Pesquisa um topico em varias fontes, rastreia citacoes e marca o que nao confere.' },
     { name: 'dw-deps-audit', description: 'Encontra pacotes desatualizados e comprometidos por supply-chain, monta plano de update por pacote e roda QA do que foi afetado.' },
     { name: 'dw-dockerize', description: 'Le um projeto, detecta stack e deps de runtime, e propoe Dockerfile e docker-compose para dev e prod com trade-offs explicitos.' },
+    { name: 'dw-execute-phase', description: 'Executa uma fase de PRD em waves com commits atomicos por task, deviation handling e gate hard de plan-checker antes de tocar codigo.' },
     { name: 'dw-find-skills', description: 'Busca no ecossistema npx skills uma skill que resolva o que voce precisa, valida e instala onde voce escolher.' },
     { name: 'dw-fix-qa', description: 'Corrige bugs do QA e retesta com evidencia em screenshot ate ficarem estaveis.' },
     { name: 'dw-functional-doc', description: 'Mapeia telas e fluxos em um dossie funcional, validado E2E com Playwright.' },
     { name: 'dw-generate-pr', description: 'Faz push da branch e abre um PR com corpo explicando o que mudou e como testar.' },
     { name: 'dw-help', description: 'Lista todos os commands e os fluxos que os conectam. Passe uma keyword para atalho contextual.' },
-    { name: 'dw-intel', description: 'Responde perguntas sobre o codebase usando suas proprias rules e intel como fonte.' },
+    { name: 'dw-intel', description: 'Responde perguntas sobre o codebase consultando .dw/intel/ (do /dw-map-codebase) com .dw/rules/ e grep como fallback.' },
+    { name: 'dw-map-codebase', description: 'Constroi um indice queryable em .dw/intel/ (stack, files, apis, deps, arch) para outros comandos pararem de re-explorar o codebase.' },
     { name: 'dw-new-project', description: 'Entrevista voce sobre stack e infra, depois faz scaffold de um monorepo com docker-compose para dev, .env, scripts, CI e rules seed.' },
+    { name: 'dw-plan-checker', description: 'Verificacao goal-backward de tasks.md de uma fase antes da execucao. Retorna PASS, REVISE ou BLOCK em 6 dimensoes.' },
     { name: 'dw-quick', description: 'Roda uma mudanca pequena e bem definida com garantias do workflow, sem precisar de PRD.' },
     { name: 'dw-redesign-ui', description: 'Audita uma pagina frontend, propoe direcoes de design que voce escolhe, e entrega o redesign.' },
     { name: 'dw-refactoring-analysis', description: 'Cataloga code smells no vocabulario de Fowler e ranqueia por impacto, P0 a P3.' },

package/lib/init.js

@@ -4,6 +4,7 @@ const { ensureDir, copyDir, writeFile, log } = require('./utils');
 const { selectLanguage } = require('./prompts');
 const { generateWrappers } = require('./wrappers');
 const { installMCPs } = require('./mcp');
+const { migrate: migrateGsd } = require('./migrate-gsd');
 
 const SCAFFOLD_DIR = path.join(__dirname, '..', 'scaffold');
 
@@ -18,6 +19,11 @@ async function run({ force = false, lang = null, mode = 'init' }) {
   console.log(`\n  dev-workflow ${isUpdate ? 'update' : 'init'}`);
   console.log(`  ${'='.repeat(40)}\n`);
 
+  // 0. GSD migration (idempotent; only runs if legacy GSD artifacts are detected)
+  if (isUpdate) {
+    migrateGsd(projectRoot);
+  }
+
   // 1. Select language
   const selectedLang = await selectLanguage(lang);
   console.log(`\n  Language: ${selectedLang}\n`);

package/lib/install-deps.js

@@ -20,11 +20,6 @@ function run() {
       check: null,
       install: 'npx react-doctor@latest --help',
     },
-    {
-      name: 'GSD (Get Shit Done)',
-      check: null,
-      install: 'npx get-shit-done-cc@latest --claude --codex --copilot --opencode --local -y',
-    },
     {
       name: 'Trivy (security scanner)',
       check: 'trivy --version',

package/lib/migrate-gsd.js

@@ -0,0 +1,164 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * One-shot GSD migration. Detects legacy GSD artifacts in a project,
+ * migrates the parts dev-workflow now provides natively, and removes
+ * the rest.
+ *
+ * Idempotent: returns silently when nothing to do.
+ *
+ * Run automatically from lib/init.js when mode === 'update'.
+ */
+function migrate(projectRoot) {
+  const planning = path.join(projectRoot, '.planning');
+  const dotClaude = path.join(projectRoot, '.claude');
+  const claudeCmdsGsd = path.join(dotClaude, 'commands', 'gsd');
+  const claudeManifest = path.join(dotClaude, 'gsd-file-manifest.json');
+
+  const hasPlanning = fs.existsSync(planning);
+  const hasGsdCmds = fs.existsSync(claudeCmdsGsd);
+  const hasGsdManifest = fs.existsSync(claudeManifest);
+
+  // Detect any gsd-* file in .claude/agents/ or .claude/hooks/
+  const gsdAgents = listMatching(path.join(dotClaude, 'agents'), /^gsd-.*\.md$/);
+  const gsdHooks = listMatching(path.join(dotClaude, 'hooks'), /^gsd-.*\.(js|cjs|mjs)$/);
+
+  const detected =
+    hasPlanning || hasGsdCmds || hasGsdManifest || gsdAgents.length > 0 || gsdHooks.length > 0;
+
+  if (!detected) return null; // nothing to migrate
+
+  console.log('\n  GSD legacy artifacts detected — migrating to dev-workflow native namespace.');
+
+  const stats = {
+    intel_files: 0,
+    state_migrated: false,
+    quick_files: 0,
+    threads_files: 0,
+    planning_archived: false,
+    cmds_removed: false,
+    agents_removed: 0,
+    hooks_removed: 0,
+    manifest_removed: false,
+  };
+
+  // 1. Migrate .planning/intel/* → .dw/intel/*
+  if (hasPlanning) {
+    const planningIntel = path.join(planning, 'intel');
+    if (fs.existsSync(planningIntel)) {
+      const dwIntel = path.join(projectRoot, '.dw', 'intel');
+      stats.intel_files = copyDirRecursive(planningIntel, dwIntel);
+    }
+
+    // 2. Migrate .planning/STATE.md → .dw/spec/active-session.md
+    const stateFile = path.join(planning, 'STATE.md');
+    if (fs.existsSync(stateFile)) {
+      const target = path.join(projectRoot, '.dw', 'spec', 'active-session.md');
+      ensureDir(path.dirname(target));
+      fs.copyFileSync(stateFile, target);
+      stats.state_migrated = true;
+    }
+
+    // 3. Migrate .planning/quick/* → .dw/spec/quick/*
+    const planningQuick = path.join(planning, 'quick');
+    if (fs.existsSync(planningQuick)) {
+      const dwQuick = path.join(projectRoot, '.dw', 'spec', 'quick');
+      stats.quick_files = copyDirRecursive(planningQuick, dwQuick);
+    }
+
+    // 4. Migrate .planning/threads/* → .dw/threads/*
+    const planningThreads = path.join(planning, 'threads');
+    if (fs.existsSync(planningThreads)) {
+      const dwThreads = path.join(projectRoot, '.dw', 'threads');
+      stats.threads_files = copyDirRecursive(planningThreads, dwThreads);
+    }
+
+    // 5. Rename .planning/ → .planning.gsd-archive-<DATE>/ (preserve for inspection)
+    const date = new Date().toISOString().split('T')[0];
+    const archive = path.join(projectRoot, `.planning.gsd-archive-${date}`);
+    if (!fs.existsSync(archive)) {
+      try {
+        fs.renameSync(planning, archive);
+        stats.planning_archived = true;
+      } catch (err) {
+        console.log(`    \x1b[33m! Could not rename .planning → ${path.basename(archive)}: ${err.message}\x1b[0m`);
+      }
+    } else {
+      console.log(`    \x1b[33m! Archive ${path.basename(archive)} already exists; leaving .planning/ in place\x1b[0m`);
+    }
+  }
+
+  // 6. Remove .claude/commands/gsd/
+  if (hasGsdCmds) {
+    rmRecursive(claudeCmdsGsd);
+    stats.cmds_removed = true;
+  }
+
+  // 7. Remove .claude/agents/gsd-*.md
+  for (const file of gsdAgents) {
+    fs.unlinkSync(path.join(dotClaude, 'agents', file));
+    stats.agents_removed++;
+  }
+
+  // 8. Remove .claude/hooks/gsd-*.js
+  for (const file of gsdHooks) {
+    fs.unlinkSync(path.join(dotClaude, 'hooks', file));
+    stats.hooks_removed++;
+  }
+
+  // 9. Remove .claude/gsd-file-manifest.json
+  if (hasGsdManifest) {
+    fs.unlinkSync(claudeManifest);
+    stats.manifest_removed = true;
+  }
+
+  // 10. Print summary
+  console.log('  Migration summary:');
+  if (stats.intel_files) console.log(`    + .dw/intel/                   (${stats.intel_files} files migrated from .planning/intel/)`);
+  if (stats.state_migrated) console.log('    + .dw/spec/active-session.md   (migrated from .planning/STATE.md)');
+  if (stats.quick_files) console.log(`    + .dw/spec/quick/              (${stats.quick_files} files migrated from .planning/quick/)`);
+  if (stats.threads_files) console.log(`    + .dw/threads/                 (${stats.threads_files} files migrated from .planning/threads/)`);
+  if (stats.planning_archived) console.log(`    ~ .planning/                   (renamed to .planning.gsd-archive-${new Date().toISOString().split('T')[0]}/ — review and delete when ready)`);
+  if (stats.cmds_removed) console.log('    - .claude/commands/gsd/        (removed; native /dw-* commands cover the use cases)');
+  if (stats.agents_removed) console.log(`    - .claude/agents/gsd-*.md      (${stats.agents_removed} files removed; native dw-* agents bundled in skills)`);
+  if (stats.hooks_removed) console.log(`    - .claude/hooks/gsd-*.js       (${stats.hooks_removed} files removed; not used by dev-workflow)`);
+  if (stats.manifest_removed) console.log('    - .claude/gsd-file-manifest.json (removed)');
+  console.log('  Done. Native /dw-intel, /dw-map-codebase, /dw-execute-phase, /dw-plan-checker, /dw-resume now provide what GSD provided.');
+  console.log();
+
+  return stats;
+}
+
+function listMatching(dir, regex) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter((name) => regex.test(name));
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function copyDirRecursive(src, dst) {
+  if (!fs.existsSync(src)) return 0;
+  ensureDir(dst);
+  let count = 0;
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const dstPath = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      count += copyDirRecursive(srcPath, dstPath);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(srcPath, dstPath);
+      count++;
+    }
+  }
+  return count;
+}
+
+function rmRecursive(target) {
+  if (!fs.existsSync(target)) return;
+  fs.rmSync(target, { recursive: true, force: true });
+}
+
+module.exports = { migrate };

package/lib/uninstall.js

@@ -97,14 +97,14 @@ function run() {
   // 6. Remove legacy .codex/skills/
   removeDir(path.join(projectRoot, '.codex', 'skills'));
 
-  // Note: .dw/rules/, .dw/spec/, .planning/ are USER DATA — never removed
+  // Note: .dw/rules/, .dw/spec/, .dw/intel/ are USER DATA — never removed
   console.log(`\n  ${'='.repeat(40)}`);
   console.log(`  Done! ${removed} removed, ${skipped} already absent`);
   console.log();
   console.log('  Preserved (user data):');
   console.log('    .dw/rules/    (project rules)');
   console.log('    .dw/spec/     (PRDs and specs)');
-  console.log('    .planning/    (GSD state)');
+  console.log('    .dw/intel/    (codebase index from /dw-map-codebase)');
   console.log();
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunosps00/dev-workflow",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "AI-driven development workflow commands for any project. Scaffolds a complete PRD-to-PR pipeline with multi-platform AI assistant support.",
   "bin": {
     "dev-workflow": "./bin/dev-workflow.js"

package/scaffold/en/commands/dw-analyze-project.md

@@ -230,19 +230,14 @@ For each module/project detected, identify:
 When React is detected, run `npx react-doctor@latest --verbose` and include the health score in the generated rules as a baseline metric.
 For Angular projects, run `ng lint` and document any warnings as baseline.
 
-<critical>If GSD is installed, running /gsd-map-codebase is MANDATORY. The command CANNOT be considered complete without executing ALL applicable steps, including generating the index in .planning/intel/.</critical>
+<critical>Running /dw-map-codebase to generate the queryable index in .dw/intel/ is MANDATORY. The command CANNOT be considered complete without it.</critical>
 
-#### Codebase Intelligence (GSD)
+#### Codebase Intelligence (native)
 
-If GSD (get-shit-done-cc) is installed in the project:
-- After generating rules in `.dw/rules/`, delegate to `/gsd-map-codebase` to create a rich index in `.planning/intel/`
-- The index includes: architectural assumptions, decision spaces, behavioral references, UI patterns
-- The index is incremental — re-running adds to the existing index, does not replace
-- Other dw-* commands can query the index via `/gsd-intel` internally
-
-If GSD is NOT installed:
-- Generate only `.dw/rules/` (current behavior)
-- Suggest: "For queryable codebase intelligence, install GSD via `npx dev-workflow install-deps`"
+After generating rules in `.dw/rules/`, delegate to `/dw-map-codebase` to create the queryable index in `.dw/intel/`:
+- The index includes: stack (`stack.json`), file graph (`files.json`), API surface (`apis.json`), dependencies (`deps.json`), architecture overview (`arch.md`)
+- The index is incremental — `/dw-map-codebase --files <list>` updates only the touched entries; full scan only when needed
+- Other dw-* commands query the index via `/dw-intel` (see the `dw-codebase-intel` bundled skill for schemas)
 
 ### Step 4: Detect Code Patterns and Conventions
 

package/scaffold/en/commands/dw-autopilot.md

@@ -68,10 +68,11 @@ If this command is invoked to resume an interrupted autopilot (via `/dw-resume`)
 
 ### Step 1: Codebase Intelligence
 
-<critical>If `.planning/intel/` exists, querying it is MANDATORY before starting.</critical>
+<critical>If `.dw/intel/` exists, querying it via `/dw-intel` is MANDATORY before starting. Falls back to `.dw/rules/` and direct grep if absent.</critical>
 
-- Query `.planning/intel/` via `/gsd-intel` (if available) or `.dw/rules/` to understand project context
+- Query `.dw/intel/` via `/dw-intel` to understand project context
 - Identify: tech stack, existing patterns, related features
+- If `.dw/intel/` is absent, suggest running `/dw-map-codebase` first for richer downstream context
 
 ### Step 2: Research (Conditional)
 
@@ -148,7 +149,7 @@ Evaluate whether tasks involve frontend:
 ### Step 8: Execution
 
 Run `/dw-run-plan` with the PRD path.
-- Follow ALL command instructions, including GSD integration (plan verification, parallel execution)
+- Follow ALL command instructions, including the native plan-checker gate (PASS required) and wave-based parallel execution via `/dw-execute-phase`
 - Each task follows `/dw-run-task` with Level 1 validation
 
 ### Step 9: Implementation Review (Loop)
@@ -247,17 +248,9 @@ Ask the user: **"Commits completed. Do you want to generate the Pull Request?"**
 - **YES**: run `/dw-generate-pr` with the target branch
 - **NO**: inform that commits are ready and the user can generate the PR manually later
 
-## GSD Integration
+## Native Engine
 
-<critical>When GSD is installed, ALL GSD integrations from each individual command MUST be executed. The autopilot is not an excuse to skip GSD steps.</critical>
-
-If GSD (get-shit-done-cc) is installed:
-- Step 1: use `/gsd-intel` for querying
-- Step 8: use plan verification + parallel execution
-- All commands: follow their individual GSD sections
-
-If GSD is NOT installed:
-- All commands work normally without GSD
+The autopilot relies on dev-workflow-native infrastructure for codebase intelligence (`/dw-map-codebase` + `/dw-intel`), plan verification (`/dw-plan-checker`), and parallel execution (`/dw-execute-phase`). All four are bundled and require no external dependencies. See the `dw-codebase-intel` and `dw-execute-phase` bundled skills under `.agents/skills/` for details.
 
 ## State Persistence
 

package/scaffold/en/commands/dw-brainstorm.md

@@ -65,7 +65,7 @@ Use this command when the user wants to:
 2. **Reframe as "How Might We"**: turn the raw idea into `How might we [verb] for [user] so that [outcome]?`. This pulls the team out of premature "solution mode".
 3. **Product Inventory (required if the product exists)**:
    - If `.dw/spec/prd-*/` has PRDs OR `.dw/rules/index.md` exists, read these artifacts to map the **current product's feature inventory** (product level, not code level).
-   - Sources to consult: `.dw/spec/prd-*/prd.md` (Overview / Main Features / User Stories sections), `.dw/rules/index.md` and `.dw/rules/<module>.md`, `.planning/intel/` if present.
+   - Sources to consult: `.dw/spec/prd-*/prd.md` (Overview / Main Features / User Stories sections), `.dw/rules/index.md` and `.dw/rules/<module>.md`, `.dw/intel/` if present (queryable via `/dw-intel`).
    - Produce a **short Feature Inventory (5-12 bullets)** before diverging: "the product today does X, Y, Z".
    - If the project is greenfield (no PRDs or rules), record: "Feature Inventory: greenfield — no product artifacts yet".
 4. If essential context is missing for the user (problem, persona, expected value), ask short and objective questions before expanding.

package/scaffold/en/commands/dw-code-review.md

@@ -29,13 +29,14 @@ When available in the project under `./.agents/skills/`, use these skills as ana
 
 ## Codebase Intelligence
 
-<critical>If `.planning/intel/` exists, querying it is MANDATORY before writing requirements. Do NOT skip this step.</critical>
-- Internally run: `/gsd-intel "documented conventions, anti-patterns, and decision spaces"`
+<critical>If `.dw/intel/` exists, querying it via `/dw-intel` is MANDATORY before reviewing. Do NOT skip this step.</critical>
+- Internally run: `/dw-intel "documented conventions and anti-patterns"`
 - Prioritize findings that violate documented conventions
-- Check if questionable architectural decisions are intentional (documented as decision spaces)
+- Check if questionable architectural decisions are intentional (documented in `.dw/rules/`)
 
-If `.planning/intel/` does NOT exist:
-- Use `.dw/rules/` as context (current behavior)
+If `.dw/intel/` does NOT exist:
+- Use `.dw/rules/` as context, falling back to grep
+- Suggest running `/dw-map-codebase` after the review for richer downstream context
 
 ## Input Variables
 

package/scaffold/en/commands/dw-create-prd.md

@@ -42,12 +42,13 @@
 
     ## Codebase Intelligence
 
-    <critical>If `.planning/intel/` exists, querying it is MANDATORY before writing requirements. Do NOT skip this step.</critical>
-    - Internally run: `/gsd-intel "existing features in the [PRD topic] domain"`
+    <critical>If `.dw/intel/` exists, querying it via `/dw-intel` is MANDATORY before writing requirements. Do NOT skip this step.</critical>
+    - Internally run: `/dw-intel "existing features in the [PRD topic] domain"`
     - Use findings to avoid duplicating existing functionality and reference established patterns
 
-    If `.planning/intel/` does NOT exist:
-    - Use `.dw/rules/` as context (current behavior)
+    If `.dw/intel/` does NOT exist:
+    - Use `.dw/rules/` as context, falling back to grep
+    - Suggest running `/dw-map-codebase` for richer downstream context
 
     ## Multi-Project Features
 

package/scaffold/en/commands/dw-create-techspec.md

@@ -29,12 +29,13 @@
 
     ## Codebase Intelligence
 
-    <critical>If `.planning/intel/` exists, querying it is MANDATORY before writing requirements. Do NOT skip this step.</critical>
-    - Internally run: `/gsd-intel "architectural patterns and technical decisions in the project"`
+    <critical>If `.dw/intel/` exists, querying it via `/dw-intel` is MANDATORY before writing the techspec. Do NOT skip this step.</critical>
+    - Internally run: `/dw-intel "architectural patterns and technical decisions in the project"`
     - Align proposals with existing patterns; flag deviations explicitly
 
-    If `.planning/intel/` does NOT exist:
-    - Use `.dw/rules/` as context (current behavior)
+    If `.dw/intel/` does NOT exist:
+    - Use `.dw/rules/` as context, falling back to grep
+    - Suggest running `/dw-map-codebase` to enrich downstream context
 
     ## Multi-Project Decision Flowchart