@brunosps00/dev-workflow 1.0.4 → 1.0.6

package/lib/subtasks.js

@@ -0,0 +1,264 @@
+const fs = require('fs');
+const path = require('path');
+const { ensureDir, writeFile } = require('./utils');
+const { readAgentRegistry } = require('./agents');
+
+const SUBTASKS_RELATIVE_DIR = path.join('.dw', 'subtasks');
+
+function run(argv = []) {
+  const action = argv[0];
+  const flags = parseFlags(argv.slice(1));
+  const projectRoot = process.cwd();
+
+  switch (action) {
+    case 'create':
+      createSubtask(projectRoot, flags);
+      break;
+    case 'complete':
+      completeSubtask(projectRoot, flags);
+      break;
+    case 'consume':
+      consumeSubtasks(projectRoot);
+      break;
+    case 'list':
+      listSubtasks(projectRoot);
+      break;
+    case undefined:
+    case 'help':
+    case '--help':
+    case '-h':
+      printHelp();
+      break;
+    default:
+      throw new Error(`Unknown subtask action: ${action}`);
+  }
+}
+
+function createSubtask(projectRoot, flags) {
+  const agent = required(flags, 'agent');
+  const goal = required(flags, 'goal');
+  validateAgent(agent);
+  ensureSubtaskLayout(projectRoot);
+
+  const now = new Date();
+  const stamp = now.toISOString().replace(/[-:]/g, '').replace(/\..+$/, 'Z');
+  const slug = `${stamp}-${slugify(goal)}`;
+  const dir = path.join(projectRoot, SUBTASKS_RELATIVE_DIR, 'pending', slug);
+  ensureDir(dir);
+
+  const task = [
+    `# Subtask: ${goal}`,
+    '',
+    `- Slug: \`${slug}\``,
+    `- Agent: \`${agent}\``,
+    `- Created: ${now.toISOString()}`,
+    '',
+    '## Objective',
+    goal,
+    '',
+    '## Allowed Files And Sources',
+    flags.files || 'Parent must fill this before dispatch if the boundary is not obvious.',
+    '',
+    '## Constraints',
+    flags.constraints || 'Use project rules. Do not request or paste the full parent transcript.',
+    '',
+    '## Expected Output',
+    flags.output || 'Structured handoff with result, files read, files changed, decisions, risks, verification, next steps, and blockers.',
+    '',
+    '## Context Budget',
+    flags.budget || 'Use the agent registry default. Return only summarized logs and relevant paths.',
+    '',
+    '## Stop Condition',
+    flags.stop || 'Stop when the expected output packet is complete or the scope exceeds the packet.',
+    '',
+    '## Handoff Command',
+    '',
+    `When complete, write a handoff markdown file and run:`,
+    '',
+    '```bash',
+    `npx @brunosps00/dev-workflow subtask complete --slug=${slug} --file=<handoff.md>`,
+    '```',
+    '',
+  ].join('\n');
+
+  writeFile(path.join(dir, 'TASK.md'), task, true);
+  console.log(path.relative(projectRoot, path.join(dir, 'TASK.md')));
+}
+
+function completeSubtask(projectRoot, flags) {
+  const slug = required(flags, 'slug');
+  const handoffFile = required(flags, 'file');
+  const taskDir = resolvePendingSubtask(projectRoot, slug);
+  const sourcePath = path.resolve(projectRoot, handoffFile);
+  if (!fs.existsSync(sourcePath)) throw new Error(`Handoff file not found: ${handoffFile}`);
+
+  const content = fs.readFileSync(sourcePath, 'utf-8');
+  validateHandoff(content);
+  fs.writeFileSync(path.join(taskDir, 'HANDOFF.md'), content.endsWith('\n') ? content : `${content}\n`, 'utf-8');
+  console.log(path.relative(projectRoot, path.join(taskDir, 'HANDOFF.md')));
+}
+
+function consumeSubtasks(projectRoot) {
+  ensureSubtaskLayout(projectRoot);
+  const pendingDir = path.join(projectRoot, SUBTASKS_RELATIVE_DIR, 'pending');
+  const entries = fs.readdirSync(pendingDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  const ready = entries
+    .map((entry) => path.join(pendingDir, entry.name))
+    .filter((dir) => fs.existsSync(path.join(dir, 'HANDOFF.md')));
+
+  if (!ready.length) {
+    console.log('No completed subtasks to consume.');
+    return;
+  }
+
+  const date = new Date().toISOString().slice(0, 10);
+  const archiveDateDir = path.join(projectRoot, SUBTASKS_RELATIVE_DIR, 'archive', date);
+  ensureDir(archiveDateDir);
+
+  console.log('Subtask handoffs consumed:\n');
+  for (const dir of ready) {
+    const handoff = fs.readFileSync(path.join(dir, 'HANDOFF.md'), 'utf-8');
+    const summary = summarizeHandoff(handoff);
+    console.log(`- ${path.basename(dir)}: ${summary}`);
+    fs.renameSync(dir, path.join(archiveDateDir, path.basename(dir)));
+  }
+  console.log('\nArchive updated. Promote durable lessons manually into .dw/STATE.md, .dw/rules/, or .dw/intel/ when they should survive beyond this workstream.');
+}
+
+function listSubtasks(projectRoot) {
+  ensureSubtaskLayout(projectRoot);
+  const pendingDir = path.join(projectRoot, SUBTASKS_RELATIVE_DIR, 'pending');
+  const entries = fs.readdirSync(pendingDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  if (!entries.length) {
+    console.log('No pending subtasks.');
+    return;
+  }
+  for (const entry of entries) {
+    const dir = path.join(pendingDir, entry.name);
+    const state = fs.existsSync(path.join(dir, 'HANDOFF.md')) ? 'complete' : 'pending';
+    console.log(`${entry.name}\t${state}`);
+  }
+}
+
+function ensureSubtaskLayout(projectRoot) {
+  const root = path.join(projectRoot, SUBTASKS_RELATIVE_DIR);
+  ensureDir(path.join(root, 'pending'));
+  ensureDir(path.join(root, 'archive'));
+  const gitignore = ['pending/', 'archive/', '', '!/.gitignore', ''].join('\n');
+  writeFile(path.join(root, '.gitignore'), gitignore, false);
+}
+
+function validateAgent(agentName) {
+  const registry = readAgentRegistry();
+  if (!registry.agents.some((agent) => agent.name === agentName)) {
+    throw new Error(`Unknown agent: ${agentName}`);
+  }
+}
+
+function validateHandoff(content) {
+  const requiredHeadings = [
+    'Objective',
+    'Result',
+    'Files Read',
+    'Files Changed',
+    'Decisions',
+    'Risks',
+    'Verification',
+    'Next Steps',
+    'Blocked Or Not Done',
+  ];
+  const missing = requiredHeadings.filter((heading) => !new RegExp(`^##\\s+${escapeRegExp(heading)}\\b`, 'mi').test(content));
+  if (missing.length) {
+    throw new Error(`Handoff is missing required headings: ${missing.join(', ')}`);
+  }
+}
+
+function summarizeHandoff(content) {
+  const result = extractSection(content, 'Result') || firstNonEmptyLine(content) || 'handoff recorded';
+  const verification = extractSection(content, 'Verification');
+  const next = extractSection(content, 'Next Steps');
+  const parts = [compact(result)];
+  if (verification) parts.push(`verification: ${compact(verification)}`);
+  if (next) parts.push(`next: ${compact(next)}`);
+  return parts.join(' | ');
+}
+
+function extractSection(content, heading) {
+  const match = content.match(new RegExp(`^##\\s+${escapeRegExp(heading)}\\b\\s*\\n([\\s\\S]*?)(?=^##\\s+|\\s*$)`, 'mi'));
+  return match ? match[1].trim() : '';
+}
+
+function firstNonEmptyLine(content) {
+  return content.split('\n').map((line) => line.trim()).find(Boolean) || '';
+}
+
+function compact(value) {
+  return value.replace(/\s+/g, ' ').slice(0, 220);
+}
+
+function resolvePendingSubtask(projectRoot, slug) {
+  const pendingDir = path.join(projectRoot, SUBTASKS_RELATIVE_DIR, 'pending');
+  if (!fs.existsSync(pendingDir)) throw new Error('No pending subtasks directory. Run subtask create first.');
+  const direct = path.join(pendingDir, slug);
+  if (fs.existsSync(direct)) return direct;
+  const matches = fs.readdirSync(pendingDir).filter((entry) => entry === slug || entry.endsWith(`-${slug}`));
+  if (matches.length === 1) return path.join(pendingDir, matches[0]);
+  if (matches.length > 1) throw new Error(`Ambiguous slug: ${slug}`);
+  throw new Error(`Pending subtask not found: ${slug}`);
+}
+
+function parseFlags(args) {
+  const flags = {};
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (!arg.startsWith('--')) continue;
+    const raw = arg.slice(2);
+    if (raw.includes('=')) {
+      const [key, ...rest] = raw.split('=');
+      flags[key] = rest.join('=');
+    } else {
+      const next = args[index + 1];
+      flags[raw] = next && !next.startsWith('--') ? next : true;
+      if (flags[raw] === next) index++;
+    }
+  }
+  return flags;
+}
+
+function required(flags, name) {
+  if (!flags[name] || flags[name] === true) throw new Error(`Missing required flag: --${name}`);
+  return String(flags[name]);
+}
+
+function slugify(value) {
+  return String(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'subtask';
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function printHelp() {
+  console.log(`
+  dev-workflow subtask
+
+  Usage:
+    npx @brunosps00/dev-workflow subtask create --agent=<name> --goal="<goal>"
+    npx @brunosps00/dev-workflow subtask complete --slug=<slug> --file=<handoff.md>
+    npx @brunosps00/dev-workflow subtask consume
+    npx @brunosps00/dev-workflow subtask list
+`);
+}
+
+module.exports = {
+  run,
+  ensureSubtaskLayout,
+  createSubtask,
+  completeSubtask,
+  consumeSubtasks,
+  listSubtasks,
+};

package/lib/uninstall.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { COMMANDS, PLATFORMS, MCP_SERVERS } = require('./constants');
+const { AGENT_TARGETS, LEGACY_AGENT_TARGETS, readAgentRegistry } = require('./agents');
 
 function run() {
   const projectRoot = process.cwd();
@@ -37,6 +38,7 @@ function run() {
   removeDir(path.join(projectRoot, '.dw', 'templates'), '.dw/templates/');
   removeDir(path.join(projectRoot, '.dw', 'references'), '.dw/references/');
   removeDir(path.join(projectRoot, '.dw', 'scripts'), '.dw/scripts/');
+  removeFile(path.join(projectRoot, '.dw', 'agent-registry.json'));
   console.log();
 
   // 2. Remove platform wrappers (only dw-* skills, not user skills)
@@ -56,23 +58,29 @@ function run() {
 
   // 3. Remove bundled skills from .agents/skills/
   console.log('  Bundled skills:');
-  // Currently-active bundled skills. If a skill is removed in a future release,
-  // add it to lib/removed-bundled-skills.js (append-only manifest used by
-  // migrate-skills.js during `dev-workflow update`); this list is just for
-  // wholesale uninstall.
-  const bundledSkills = [
-    'dw-ui-discipline',
-    'dw-testing-discipline',
-    'humanizer',
-    'remotion-best-practices',
-    'security-review',
-    'vercel-react-best-practices',
-  ];
+  const skillsDir = path.join(__dirname, '..', 'scaffold', 'skills');
+  const bundledSkills = fs.existsSync(skillsDir)
+    ? fs.readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name)
+    : [];
   for (const skill of bundledSkills) {
     removeDir(path.join(projectRoot, '.agents', 'skills', skill));
   }
   console.log();
 
+  // 3.5. Remove generated dev-workflow agents from platform folders.
+  console.log('  Agents:');
+  const registry = readAgentRegistry();
+  for (const agent of registry.agents) {
+    for (const target of Object.values(AGENT_TARGETS)) {
+      removeFile(path.join(projectRoot, target.dir, target.fileName(agent.name)));
+    }
+    for (const target of Object.values(LEGACY_AGENT_TARGETS)) {
+      removeFile(path.join(projectRoot, target.dir, target.fileName(agent.name)));
+    }
+  }
+  removeFile(path.join(projectRoot, '.agents', 'agents', 'README.md'));
+  console.log();
+
   // 4. Remove MCP servers from .claude/settings.json
   console.log('  MCP Servers:');
   const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
@@ -97,6 +105,7 @@ function run() {
 
   // 5. Remove .opencode/package.json
   removeFile(path.join(projectRoot, '.opencode', 'package.json'));
+  removeFile(path.join(projectRoot, '.dw', 'install-state.json'));
 
   // 6. Remove legacy .codex/skills/
   removeDir(path.join(projectRoot, '.codex', 'skills'));

package/lib/utils.js

@@ -60,6 +60,36 @@ function copyDir(srcDir, destDir, force = false, overridesDir = null) {
   return results;
 }
 
+function listFilesRecursive(dirPath) {
+  const files = [];
+  if (!fs.existsSync(dirPath)) return files;
+
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listFilesRecursive(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+function readJson(filePath, fallback = null) {
+  if (!fs.existsSync(filePath)) return fallback;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n', 'utf-8');
+}
+
 /**
  * Upsert a delimited block inside an existing file.
  *
@@ -113,4 +143,15 @@ function log(status, filePath) {
   console.log(`  ${icon} ${relative} [${status}]`);
 }
 
-module.exports = { ensureDir, fileExists, copyFile, writeFile, copyDir, upsertDelimitedBlock, log };
+module.exports = {
+  ensureDir,
+  fileExists,
+  copyFile,
+  writeFile,
+  copyDir,
+  listFilesRecursive,
+  readJson,
+  writeJson,
+  upsertDelimitedBlock,
+  log,
+};

package/lib/wrappers.js

@@ -3,7 +3,7 @@ const { PLATFORMS } = require('./constants');
 const { writeFile, log } = require('./utils');
 
 function generateWrappers(projectRoot, commands, force = false) {
-  const results = { created: 0, skipped: 0, overwritten: 0 };
+  const results = { created: 0, skipped: 0, overwritten: 0, files: [] };
 
   for (const [platformName, platform] of Object.entries(PLATFORMS)) {
     for (const cmd of commands) {
@@ -18,6 +18,7 @@ function generateWrappers(projectRoot, commands, force = false) {
       const content = platform.wrapperTemplate(cmd.name, cmd.description);
       const status = writeFile(skillFile, content, force);
       results[status]++;
+      results.files.push(skillFile);
       log(status, skillFile);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunosps00/dev-workflow",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "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/agent-registry.json

@@ -0,0 +1,272 @@
+{
+  "schema_version": "2.0",
+  "agents": [
+    {
+      "name": "dw-code-explorer",
+      "module": "core",
+      "mode": "read-only",
+      "description": "Trace entry points, flows, dependencies, and existing patterns before planning or fixing code.",
+      "context_mode": "fresh",
+      "tool_policy": "read-only",
+      "max_turns": 8,
+      "input_budget_words": 900,
+      "output_budget_words": 900,
+      "parallel_safe": true,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["unfamiliar code", "planning research", "wide grep or dependency tracing"],
+      "avoid_when": ["small direct edit", "needs full parent conversation", "implementation is already obvious"]
+    },
+    {
+      "name": "dw-planner",
+      "module": "core",
+      "mode": "read-only",
+      "description": "Turn requirements into implementation slices, dependencies, risks, and verification criteria.",
+      "context_mode": "fresh",
+      "tool_policy": "read-only",
+      "max_turns": 8,
+      "input_budget_words": 900,
+      "output_budget_words": 900,
+      "parallel_safe": true,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["planning research", "task decomposition", "risk mapping"],
+      "avoid_when": ["small direct edit", "requirements need user clarification", "implementation and planning are tightly coupled"]
+    },
+    {
+      "name": "dw-build-fixer",
+      "module": "core",
+      "mode": "write",
+      "description": "Fix build, typecheck, and lint failures with minimal diffs.",
+      "context_mode": "fresh",
+      "tool_policy": "write-scoped",
+      "max_turns": 12,
+      "input_budget_words": 1200,
+      "output_budget_words": 1200,
+      "parallel_safe": false,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["failing build command", "typecheck failure", "lint failure after a known command"],
+      "avoid_when": ["no failing command exists", "fix needs architecture decision", "write scope is unclear"]
+    },
+    {
+      "name": "dw-code-reviewer",
+      "module": "core",
+      "mode": "read-only",
+      "description": "Review changed code for correctness, maintainability, and defensible risks.",
+      "context_mode": "fresh",
+      "tool_policy": "read-only",
+      "max_turns": 8,
+      "input_budget_words": 900,
+      "output_budget_words": 900,
+      "parallel_safe": true,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["independent code review", "PR readiness", "changed files with clear diff"],
+      "avoid_when": ["implementation is still moving", "no files or diff are provided", "style-only preference review"]
+    },
+    {
+      "name": "dw-test-author",
+      "module": "core",
+      "mode": "write",
+      "description": "Add focused tests and regression coverage using project conventions.",
+      "context_mode": "fresh",
+      "tool_policy": "write-scoped",
+      "max_turns": 12,
+      "input_budget_words": 1200,
+      "output_budget_words": 1200,
+      "parallel_safe": false,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["focused regression coverage", "clear invariant to test", "known nearby test pattern"],
+      "avoid_when": ["behavior is unspecified", "test suite architecture needs redesign", "write scope is unclear"]
+    },
+    {
+      "name": "dw-security-reviewer",
+      "module": "security",
+      "mode": "read-only",
+      "description": "Review sensitive surfaces such as auth, secrets, uploads, SQL, SSRF, and XSS.",
+      "context_mode": "fresh",
+      "tool_policy": "read-only",
+      "max_turns": 8,
+      "input_budget_words": 900,
+      "output_budget_words": 900,
+      "parallel_safe": true,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["auth or authorization changes", "input boundary review", "supply-chain or secret risk"],
+      "avoid_when": ["purely cosmetic diff", "no sensitive surface is involved", "requires exploit research outside repo scope"]
+    },
+    {
+      "name": "dw-silent-failure-hunter",
+      "module": "security",
+      "mode": "read-only",
+      "description": "Find swallowed errors, dangerous fallbacks, lost stack traces, and missing propagation.",
+      "context_mode": "fresh",
+      "tool_policy": "read-only",
+      "max_turns": 8,
+      "input_budget_words": 900,
+      "output_budget_words": 900,
+      "parallel_safe": true,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["error handling review", "async detachment review", "fallback or retry changes"],
+      "avoid_when": ["no error path changed", "requires broad audit beyond input packet", "implementation is still in progress"]
+    },
+    {
+      "name": "dw-qa-runner",
+      "module": "frontend",
+      "mode": "write-qa",
+      "description": "Create and run UI/API QA scripts, evidence, and retest logs under QA folders.",
+      "context_mode": "fresh",
+      "tool_policy": "qa-write",
+      "max_turns": 16,
+      "input_budget_words": 1200,
+      "output_budget_words": 1500,
+      "parallel_safe": false,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["behavior-level QA", "Playwright or API flow validation", "retest evidence collection"],
+      "avoid_when": ["unit-only change", "environment cannot run", "bug fixing was not assigned"]
+    },
+    {
+      "name": "dw-typescript-reviewer",
+      "module": "typescript",
+      "mode": "read-only",
+      "description": "Review TypeScript and JavaScript changes for type safety, async correctness, and web or Node risks.",
+      "context_mode": "fresh",
+      "tool_policy": "read-only",
+      "max_turns": 8,
+      "input_budget_words": 900,
+      "output_budget_words": 900,
+      "parallel_safe": true,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["TypeScript or JavaScript diff review", "React or Node boundary changes", "type safety review"],
+      "avoid_when": ["global audit without paths", "non-TypeScript diff", "style-only review"]
+    },
+    {
+      "name": "dw-typescript-build-fixer",
+      "module": "typescript",
+      "mode": "write",
+      "description": "Fix TypeScript and JavaScript build/type errors with minimal changes.",
+      "context_mode": "fresh",
+      "tool_policy": "write-scoped",
+      "max_turns": 12,
+      "input_budget_words": 1200,
+      "output_budget_words": 1200,
+      "parallel_safe": false,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["TypeScript typecheck failure", "JavaScript build failure", "failing lint command"],
+      "avoid_when": ["no failing command exists", "fix requires API redesign", "strictness would need to be weakened"]
+    },
+    {
+      "name": "dw-python-reviewer",
+      "module": "python",
+      "mode": "read-only",
+      "description": "Review Python changes for correctness, typing, async behavior, and framework risks.",
+      "context_mode": "fresh",
+      "tool_policy": "read-only",
+      "max_turns": 8,
+      "input_budget_words": 900,
+      "output_budget_words": 900,
+      "parallel_safe": true,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["Python diff review", "async or exception handling review", "framework boundary review"],
+      "avoid_when": ["global audit without paths", "non-Python diff", "style-only review"]
+    },
+    {
+      "name": "dw-python-build-fixer",
+      "module": "python",
+      "mode": "write",
+      "description": "Fix Python test, import, typing, and packaging failures with minimal changes.",
+      "context_mode": "fresh",
+      "tool_policy": "write-scoped",
+      "max_turns": 12,
+      "input_budget_words": 1200,
+      "output_budget_words": 1200,
+      "parallel_safe": false,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["pytest failure", "ruff or mypy failure", "import or packaging failure"],
+      "avoid_when": ["no failing command exists", "behavior change is not proven", "dependency decision is required"]
+    },
+    {
+      "name": "dw-csharp-reviewer",
+      "module": "csharp",
+      "mode": "read-only",
+      "description": "Review C#/.NET code for API, async, dependency injection, and data-access risks.",
+      "context_mode": "fresh",
+      "tool_policy": "read-only",
+      "max_turns": 8,
+      "input_budget_words": 900,
+      "output_budget_words": 900,
+      "parallel_safe": true,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["C# or .NET diff review", "DI or async review", "EF/data access review"],
+      "avoid_when": ["global audit without paths", "non-.NET diff", "style-only review"]
+    },
+    {
+      "name": "dw-dotnet-build-fixer",
+      "module": "csharp",
+      "mode": "write",
+      "description": "Fix .NET build, test, restore, and analyzer failures with minimal changes.",
+      "context_mode": "fresh",
+      "tool_policy": "write-scoped",
+      "max_turns": 12,
+      "input_budget_words": 1200,
+      "output_budget_words": 1200,
+      "parallel_safe": false,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["dotnet restore failure", "dotnet build or test failure", "analyzer failure"],
+      "avoid_when": ["no failing command exists", "package or framework decision is required", "project structure redesign is needed"]
+    },
+    {
+      "name": "dw-rust-reviewer",
+      "module": "rust",
+      "mode": "read-only",
+      "description": "Review Rust changes for ownership, error handling, concurrency, unsafe, and API design risks.",
+      "context_mode": "fresh",
+      "tool_policy": "read-only",
+      "max_turns": 8,
+      "input_budget_words": 900,
+      "output_budget_words": 900,
+      "parallel_safe": true,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["Rust diff review", "unsafe or concurrency review", "public API review"],
+      "avoid_when": ["global audit without paths", "non-Rust diff", "style-only review"]
+    },
+    {
+      "name": "dw-rust-build-fixer",
+      "module": "rust",
+      "mode": "write",
+      "description": "Fix Rust cargo check/test/clippy failures with minimal changes.",
+      "context_mode": "fresh",
+      "tool_policy": "write-scoped",
+      "max_turns": 12,
+      "input_budget_words": 1200,
+      "output_budget_words": 1200,
+      "parallel_safe": false,
+      "handoff_required": true,
+      "skill_policy": "lazy",
+      "recommended_for": ["cargo check failure", "cargo test failure", "cargo clippy failure"],
+      "avoid_when": ["no failing command exists", "public API decision is needed", "warning suppression would be broad"]
+    }
+  ],
+  "commands": {
+    "dw-plan": ["dw-code-explorer", "dw-planner"],
+    "dw-run": ["dw-build-fixer", "dw-test-author"],
+    "dw-bugfix": ["dw-code-explorer", "dw-build-fixer", "dw-test-author", "dw-silent-failure-hunter"],
+    "dw-review": ["dw-code-reviewer", "dw-security-reviewer", "dw-silent-failure-hunter"],
+    "dw-qa": ["dw-qa-runner", "dw-test-author"],
+    "dw-intel": ["dw-code-explorer"],
+    "dw-subtask-start": ["dw-code-explorer", "dw-planner", "dw-build-fixer", "dw-test-author"],
+    "dw-subtask-complete": [],
+    "dw-subtask-resume": []
+  }
+}