brain-dev 0.2.0 → 0.3.0

package/README.md

@@ -106,6 +106,35 @@ Brain creates a plan, executes it, and commits — all in one flow. No discuss,
 
 Quick tasks live in `.brain/quick/`, separate from phases. Tracked in STATE.md.
 
+## Significant Tasks
+
+For features that need more than a quick fix but less than a new project:
+
+```bash
+/brain:new-task "add payment integration with Stripe"
+```
+
+Brain runs the full pipeline: discuss → plan → execute → verify → complete.
+
+```bash
+/brain:new-task --research "add rate limiting"   # With light research
+/brain:new-task --light "fix auth redirect"       # Skip discuss + verify
+/brain:new-task --continue                        # Resume current task
+/brain:new-task --list                            # List all tasks
+```
+
+After completion, promote to your roadmap:
+
+```bash
+/brain:new-task --promote 1    # Adds task as a phase in ROADMAP.md
+```
+
+| Mode | Pipeline |
+|------|----------|
+| Standard | discuss → plan → execute → verify → complete |
+| `--light` | plan → execute → commit |
+| `--research` | discuss → research → plan → execute → verify → complete |
+
 ## State Machine
 
 Brain tracks progress through a deterministic state machine:
@@ -146,6 +175,7 @@ No supply chain risk. No transitive vulnerabilities. No `node_modules` bloat.
 | `/brain:verify` | 3-level verification against must-haves |
 | `/brain:complete` | Mark phase done, advance to next |
 | `/brain:quick` | Quick task — skip the ceremony |
+| `/brain:new-task` | Significant task — full pipeline without a new project |
 
 ### Session
 | Command | Description |

package/bin/brain-tools.cjs

@@ -132,6 +132,10 @@ async function main() {
       await require('./lib/commands/quick.cjs').run(args.slice(1));
       break;
 
+    case 'new-task':
+      await require('./lib/commands/new-task.cjs').run(args.slice(1));
+      break;
+
     case 'execute':
       if (args.includes('--auto') || args.includes('--dry-run') || args.includes('--stop')) {
         await require('./lib/commands/auto.cjs').run(args.slice(1));

package/bin/lib/commands/new-task.cjs

@@ -0,0 +1,522 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { parseArgs } = require('node:util');
+const { readState, writeState } = require('../state.cjs');
+const { logEvent } = require('../logger.cjs');
+const { output, error, prefix } = require('../core.cjs');
+const { recordInvocation, estimateTokens } = require('../cost.cjs');
+
+async function run(args = [], opts = {}) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      research: { type: 'boolean', default: false },
+      light: { type: 'boolean', default: false },
+      continue: { type: 'boolean', default: false },
+      list: { type: 'boolean', default: false },
+      promote: { type: 'string' },
+      json: { type: 'boolean', default: false }
+    },
+    strict: false,
+    allowPositionals: true
+  });
+
+  const brainDir = opts.brainDir || path.join(process.cwd(), '.brain');
+  const state = readState(brainDir);
+
+  if (!state || !state.project?.initialized) {
+    error("Project not initialized. Run '/brain:new-project' first.");
+    return { error: 'not-initialized' };
+  }
+
+  // Handle --list
+  if (values.list) return handleList(brainDir, state);
+
+  // Handle --promote N
+  if (values.promote) {
+    const taskNum = parseInt(values.promote, 10);
+    if (isNaN(taskNum) || taskNum < 1) {
+      error("--promote requires a valid task number. Usage: brain-dev new-task --promote <N>");
+      return { error: 'invalid-task-number' };
+    }
+    return handlePromote(brainDir, state, taskNum);
+  }
+
+  // Handle --continue (resume current task)
+  if (values.continue) return handleContinue(brainDir, state);
+
+  // New task creation
+  const description = positionals.join(' ').trim();
+  if (!description) {
+    error("Usage: brain-dev new-task \"description\" [--research] [--light]");
+    return { error: 'no-description' };
+  }
+
+  return handleNewTask(brainDir, state, description, values);
+}
+
+function handleNewTask(brainDir, state, description, options) {
+  // Create task directory and metadata
+  const taskNum = (state.tasks?.count || 0) + 1;
+  const slug = description
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 40) || 'task';
+
+  const taskDir = path.join(brainDir, 'tasks', `${String(taskNum).padStart(2, '0')}-${slug}`);
+  fs.mkdirSync(taskDir, { recursive: true });
+
+  const mode = options.light ? 'light' : 'standard';
+  const taskMeta = {
+    num: taskNum,
+    slug,
+    description,
+    created: new Date().toISOString(),
+    status: 'initialized',
+    mode,
+    research: options.research || false,
+    parent_phase: state.phase?.current || null,
+    promoted_to_phase: null,
+    completed: null
+  };
+
+  fs.writeFileSync(path.join(taskDir, 'task.json'), JSON.stringify(taskMeta, null, 2));
+
+  // Update state
+  state.tasks = state.tasks || { current: null, count: 0, active: [], history: [] };
+  state.tasks.current = taskNum;
+  state.tasks.count = taskNum;
+  state.tasks.active.push({ num: taskNum, slug, status: 'initialized', description });
+  writeState(brainDir, state);
+
+  logEvent(brainDir, 0, { type: 'task-init', task: taskNum, slug, description, mode });
+
+  // Determine first step
+  const firstStep = mode === 'light' ? 'plan' : 'discuss';
+
+  // Build step instructions
+  const steps = buildStepInstructions(taskNum, slug, taskDir, brainDir, mode, options.research, description);
+
+  const humanLines = [
+    prefix(`Task #${taskNum} created: ${description}`),
+    prefix(`Mode: ${mode}${options.research ? ' + research' : ''}`),
+    prefix(`Directory: .brain/tasks/${String(taskNum).padStart(2, '0')}-${slug}/`),
+    '',
+    prefix(`Pipeline: ${mode === 'light' ? 'plan -> execute -> commit' : 'discuss -> plan -> execute -> verify -> complete'}`),
+    '',
+    prefix(`Next step: ${firstStep}`),
+    '',
+    steps[firstStep]
+  ].join('\n');
+
+  const result = {
+    action: 'task-created',
+    task: taskMeta,
+    nextStep: firstStep,
+    taskDir,
+    steps,
+    instructions: steps[firstStep]
+  };
+
+  output(result, humanLines);
+  return result;
+}
+
+function buildStepInstructions(taskNum, slug, taskDir, brainDir, mode, research, description) {
+  const padded = String(taskNum).padStart(2, '0');
+  const steps = {};
+
+  // DISCUSS step
+  steps.discuss = [
+    `## Step 1: Discuss — Task #${taskNum}`,
+    '',
+    `Discuss the architectural approach for: "${description}"`,
+    '',
+    'Questions to explore:',
+    '1. What is the best approach for this task?',
+    '2. Are there existing patterns in the codebase to follow?',
+    '3. What are the risks or edge cases?',
+    '4. What dependencies does this have?',
+    '',
+    'After discussion, save decisions to:',
+    `\`${taskDir}/CONTEXT.md\``,
+    '',
+    'Then run: `npx brain-dev new-task --continue`'
+  ].join('\n');
+
+  // RESEARCH step (optional)
+  if (research) {
+    steps.research = [
+      `## Step 1.5: Research — Task #${taskNum}`,
+      '',
+      `Research the approach for: "${description}"`,
+      '',
+      'Focus on:',
+      '1. How does the existing codebase handle similar features?',
+      '2. What are the best practices for this type of change?',
+      '',
+      'Save findings to:',
+      `\`${taskDir}/RESEARCH.md\``,
+      '',
+      'Then run: `npx brain-dev new-task --continue`'
+    ].join('\n');
+  }
+
+  // PLAN step
+  steps.plan = [
+    `## Step 2: Plan — Task #${taskNum}`,
+    '',
+    `Create an execution plan for: "${description}"`,
+    '',
+    'Constraints:',
+    '- Max 3-4 tasks (this is a focused task, not a full phase)',
+    '- Target ~50% context budget',
+    '- Each task should be atomic and testable',
+    '- Include must_haves for verification',
+    '',
+    `Read context: \`${taskDir}/CONTEXT.md\` (if exists)`,
+    research ? `Read research: \`${taskDir}/RESEARCH.md\` (if exists)` : '',
+    '',
+    `Write plan to: \`${taskDir}/PLAN-1.md\``,
+    'Use standard Brain plan format with YAML frontmatter.',
+    '',
+    'Then run: `npx brain-dev new-task --continue`'
+  ].filter(Boolean).join('\n');
+
+  // EXECUTE step
+  steps.execute = [
+    `## Step 3: Execute — Task #${taskNum}`,
+    '',
+    `Execute the plan at: \`${taskDir}/PLAN-1.md\``,
+    '',
+    'Instructions:',
+    '- Follow the plan tasks sequentially',
+    '- Make atomic commits per task',
+    '- If a task fails, retry once then escalate',
+    '',
+    `Write summary to: \`${taskDir}/SUMMARY-1.md\``,
+    'Include: key files modified, decisions made, Self-Check status.',
+    '',
+    'Then run: `npx brain-dev new-task --continue`'
+  ].join('\n');
+
+  // VERIFY step
+  if (mode !== 'light') {
+    steps.verify = [
+      `## Step 4: Verify — Task #${taskNum}`,
+      '',
+      `Verify the execution results against must_haves in: \`${taskDir}/PLAN-1.md\``,
+      '',
+      'Verification levels:',
+      '1. EXISTS: Files exist and are non-empty',
+      '2. SUBSTANTIVE: Contains real implementation (no stubs)',
+      '3. WIRED: Properly imported and consumed',
+      '',
+      `Write results to: \`${taskDir}/VERIFICATION.md\``,
+      '',
+      'Then run: `npx brain-dev new-task --continue`'
+    ].join('\n');
+  }
+
+  // COMPLETE step
+  steps.complete = [
+    `## Step 5: Complete — Task #${taskNum}`,
+    '',
+    'Task completion options:',
+    '',
+    '**Option A: Keep as standalone task**',
+    '`npx brain-dev new-task --continue` (will auto-complete)',
+    '',
+    '**Option B: Promote to roadmap phase**',
+    `\`npx brain-dev new-task --promote ${taskNum}\``,
+    'This adds the task as a new phase in ROADMAP.md.',
+    '',
+    'Commit suggestion:',
+    `\`git add -A && git commit -m "feat(task-${padded}): ${slug}"\``
+  ].join('\n');
+
+  return steps;
+}
+
+function handleContinue(brainDir, state) {
+  const taskNum = state.tasks?.current;
+  if (!taskNum) {
+    error("No active task. Start one with: brain-dev new-task \"description\"");
+    return { error: 'no-active-task' };
+  }
+
+  // Find task directory
+  const tasksDir = path.join(brainDir, 'tasks');
+  if (!fs.existsSync(tasksDir)) {
+    error("No tasks directory found.");
+    return { error: 'no-tasks-dir' };
+  }
+
+  const padded = String(taskNum).padStart(2, '0');
+  const dirs = fs.readdirSync(tasksDir).filter(d => d.startsWith(padded + '-'));
+  if (dirs.length === 0) {
+    error(`Task #${taskNum} directory not found.`);
+    return { error: 'task-not-found' };
+  }
+
+  const taskDir = path.join(tasksDir, dirs[0]);
+  const taskMeta = JSON.parse(fs.readFileSync(path.join(taskDir, 'task.json'), 'utf8'));
+
+  // Determine current step based on what files exist
+  const hasContext = fs.existsSync(path.join(taskDir, 'CONTEXT.md'));
+  const hasResearch = fs.existsSync(path.join(taskDir, 'RESEARCH.md'));
+  const hasPlan = fs.existsSync(path.join(taskDir, 'PLAN-1.md'));
+  const hasSummary = fs.existsSync(path.join(taskDir, 'SUMMARY-1.md'));
+  const hasVerification = fs.existsSync(path.join(taskDir, 'VERIFICATION.md'));
+
+  const isLight = taskMeta.mode === 'light';
+  let nextStep;
+  let newStatus;
+
+  if (!hasContext && !isLight) {
+    nextStep = 'discuss';
+    newStatus = 'discussing';
+  } else if (taskMeta.research && !hasResearch) {
+    nextStep = 'research';
+    newStatus = 'researching';
+  } else if (!hasPlan) {
+    nextStep = 'plan';
+    newStatus = 'planning';
+  } else if (!hasSummary) {
+    nextStep = 'execute';
+    newStatus = 'executing';
+  } else if (!hasVerification && !isLight) {
+    nextStep = 'verify';
+    newStatus = 'verifying';
+  } else {
+    // All steps done — complete the task
+    return handleTaskComplete(brainDir, state, taskNum, taskDir, taskMeta);
+  }
+
+  // Update status
+  taskMeta.status = newStatus;
+  fs.writeFileSync(path.join(taskDir, 'task.json'), JSON.stringify(taskMeta, null, 2));
+
+  // Update state
+  state.tasks.active = state.tasks.active || [];
+  const activeIdx = state.tasks.active.findIndex(t => t.num === taskNum);
+  if (activeIdx >= 0) state.tasks.active[activeIdx].status = newStatus;
+  writeState(brainDir, state);
+
+  // Build step instructions
+  const steps = buildStepInstructions(
+    taskNum, taskMeta.slug, taskDir, brainDir,
+    taskMeta.mode, taskMeta.research, taskMeta.description
+  );
+
+  logEvent(brainDir, 0, { type: 'task-continue', task: taskNum, step: nextStep });
+
+  // Record cost for execute step
+  if (nextStep === 'execute' && hasPlan) {
+    try {
+      const planContent = fs.readFileSync(path.join(taskDir, 'PLAN-1.md'), 'utf8');
+      const inputTokens = estimateTokens(planContent);
+      recordInvocation(brainDir, {
+        agent: 'executor', phase: 0, plan: '01',
+        model: 'inherit', input_tokens: inputTokens, output_tokens: 0
+      });
+    } catch { /* non-fatal */ }
+  }
+
+  const humanLines = [
+    prefix(`Task #${taskNum}: ${taskMeta.description}`),
+    prefix(`Status: ${newStatus}`),
+    prefix(`Next step: ${nextStep}`),
+    '',
+    steps[nextStep]
+  ].join('\n');
+
+  output({
+    action: 'task-continue',
+    task: taskMeta,
+    nextStep,
+    instructions: steps[nextStep]
+  }, humanLines);
+
+  return { action: 'task-continue', task: taskMeta, nextStep };
+}
+
+function handleTaskComplete(brainDir, state, taskNum, taskDir, taskMeta) {
+  taskMeta.status = 'complete';
+  taskMeta.completed = new Date().toISOString();
+  fs.writeFileSync(path.join(taskDir, 'task.json'), JSON.stringify(taskMeta, null, 2));
+
+  // Move from active to history
+  state.tasks.active = state.tasks.active.filter(t => t.num !== taskNum);
+  state.tasks.history.push({
+    num: taskNum,
+    slug: taskMeta.slug,
+    description: taskMeta.description,
+    mode: taskMeta.mode,
+    completed: taskMeta.completed,
+    promoted_to_phase: null
+  });
+  state.tasks.current = null;
+  writeState(brainDir, state);
+
+  logEvent(brainDir, 0, { type: 'task-complete', task: taskNum, slug: taskMeta.slug });
+
+  const padded = String(taskNum).padStart(2, '0');
+  const humanLines = [
+    prefix(`Task #${taskNum} complete: ${taskMeta.description}`),
+    '',
+    prefix('Options:'),
+    prefix('  1. Keep as standalone task (done!)'),
+    prefix(`  2. Promote to roadmap phase: brain-dev new-task --promote ${taskNum}`),
+    '',
+    prefix(`Suggested commit: git add -A && git commit -m "feat(task-${padded}): ${taskMeta.slug}"`)
+  ].join('\n');
+
+  output({
+    action: 'task-complete',
+    task: taskMeta,
+    promote_command: `brain-dev new-task --promote ${taskNum}`
+  }, humanLines);
+
+  return { action: 'task-complete', task: taskMeta };
+}
+
+function handlePromote(brainDir, state, taskNum) {
+  // Guard: phases must exist for promotion
+  if (!state.phase || !Array.isArray(state.phase.phases)) {
+    error("Project phases not initialized. Run '/brain:new-project' first.");
+    return { error: 'no-phases' };
+  }
+
+  // Find the task
+  const tasksDir = path.join(brainDir, 'tasks');
+  if (!fs.existsSync(tasksDir)) {
+    error(`No tasks directory found. Create a task first: brain-dev new-task "description"`);
+    return { error: 'no-tasks-dir' };
+  }
+  const padded = String(taskNum).padStart(2, '0');
+  const dirs = fs.readdirSync(tasksDir).filter(d => d.startsWith(padded + '-'));
+
+  if (dirs.length === 0) {
+    error(`Task #${taskNum} not found.`);
+    return { error: 'task-not-found' };
+  }
+
+  const taskDir = path.join(tasksDir, dirs[0]);
+  const taskMeta = JSON.parse(fs.readFileSync(path.join(taskDir, 'task.json'), 'utf8'));
+
+  // Insert as a new phase after current phase
+  try {
+    const { parseRoadmap, insertPhase, writeRoadmap } = require('../roadmap.cjs');
+    const roadmapPath = path.join(brainDir, 'ROADMAP.md');
+
+    if (!fs.existsSync(roadmapPath)) {
+      error("No ROADMAP.md found. Cannot promote without a roadmap.");
+      return { error: 'no-roadmap' };
+    }
+
+    const roadmapData = parseRoadmap(brainDir);
+    const afterPhase = state.phase?.current || roadmapData.phases.length;
+
+    const updatedRoadmap = insertPhase(roadmapData, afterPhase, {
+      name: taskMeta.description,
+      goal: `Implement: ${taskMeta.description} (promoted from task #${taskNum})`,
+      requirements: taskMeta.requirements || [],
+      status: taskMeta.status === 'complete' ? 'Complete' : 'In Progress'
+    });
+
+    writeRoadmap(brainDir, updatedRoadmap);
+
+    // Find the newly inserted phase (it was not in the original roadmapData)
+    const newPhase = updatedRoadmap.phases.find(
+      p => !roadmapData.phases.some(op => op.number === p.number)
+    );
+
+    // Update task metadata
+    taskMeta.promoted_to_phase = newPhase ? newPhase.number : afterPhase;
+    fs.writeFileSync(path.join(taskDir, 'task.json'), JSON.stringify(taskMeta, null, 2));
+
+    // Update state
+    state.phase.total = updatedRoadmap.phases.length;
+    state.phase.phases.push({
+      number: taskMeta.promoted_to_phase,
+      name: taskMeta.description,
+      status: taskMeta.status === 'complete' ? 'complete' : 'pending',
+      goal: newPhase ? newPhase.goal : taskMeta.description
+    });
+
+    // Update history
+    const historyEntry = state.tasks.history.find(t => t.num === taskNum);
+    if (historyEntry) historyEntry.promoted_to_phase = taskMeta.promoted_to_phase;
+
+    writeState(brainDir, state);
+
+    logEvent(brainDir, 0, { type: 'task-promote', task: taskNum, phase: taskMeta.promoted_to_phase });
+
+    // Copy artifacts to phase directory
+    const phaseSlug = taskMeta.slug;
+    const phasePadded = Number.isInteger(taskMeta.promoted_to_phase)
+      ? String(taskMeta.promoted_to_phase).padStart(2, '0')
+      : String(taskMeta.promoted_to_phase).replace('.', '_');
+    const phaseDir = path.join(brainDir, 'phases', `${phasePadded}-${phaseSlug}`);
+    fs.mkdirSync(phaseDir, { recursive: true });
+
+    // Copy plan, summary, verification if they exist
+    for (const file of ['PLAN-1.md', 'SUMMARY-1.md', 'VERIFICATION.md', 'CONTEXT.md']) {
+      const src = path.join(taskDir, file);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, path.join(phaseDir, file));
+      }
+    }
+
+    const humanLines = [
+      prefix(`Task #${taskNum} promoted to Phase ${taskMeta.promoted_to_phase}`),
+      prefix(`Phase: ${taskMeta.description}`),
+      prefix(`Artifacts copied to: .brain/phases/${phasePadded}-${phaseSlug}/`),
+      prefix('ROADMAP.md updated')
+    ].join('\n');
+
+    output({ action: 'task-promoted', task: taskMeta, phase: newPhase }, humanLines);
+    return { action: 'task-promoted', task: taskMeta, phase: newPhase };
+
+  } catch (e) {
+    error(`Promotion failed: ${e.message}`);
+    return { error: 'promotion-failed', message: e.message };
+  }
+}
+
+function handleList(brainDir, state) {
+  const tasks = state.tasks || { active: [], history: [], count: 0 };
+
+  const lines = [prefix(`Tasks (${tasks.count} total)`)];
+
+  if (tasks.active.length > 0) {
+    lines.push('');
+    lines.push(prefix('Active:'));
+    for (const t of tasks.active) {
+      lines.push(prefix(`  #${t.num} ${t.slug} (${t.status})`));
+    }
+  }
+
+  if (tasks.history.length > 0) {
+    lines.push('');
+    lines.push(prefix('Completed:'));
+    for (const t of tasks.history.slice(-10)) {
+      const promoted = t.promoted_to_phase ? ` -> Phase ${t.promoted_to_phase}` : '';
+      lines.push(prefix(`  #${t.num} ${t.slug}${promoted}`));
+    }
+  }
+
+  if (tasks.count === 0) {
+    lines.push(prefix('  No tasks yet. Create one: brain-dev new-task "description"'));
+  }
+
+  const result = { action: 'task-list', tasks };
+  output(result, lines.join('\n'));
+  return result;
+}
+
+module.exports = { run };

package/bin/lib/commands.cjs

@@ -65,6 +65,15 @@ const COMMANDS = [
     needsState: true,
     args: '  --full            Enable plan checking + verification\n  --execute --task N  Execute task N\n  --verify --task N   Verify task N (--full only)\n  --complete --task N Complete and commit task N'
   },
+  {
+    name: 'new-task',
+    description: 'Create a significant task with full pipeline',
+    usage: 'brain-dev new-task "description" [--research] [--light]',
+    group: 'Lifecycle',
+    implemented: true,
+    needsState: true,
+    args: '  --research     Include light research phase\n  --light        Skip discuss and verify (fast mode)\n  --continue     Resume the current active task\n  --list         List all tasks\n  --promote N    Promote task N to roadmap phase'
+  },
   {
     name: 'execute',
     description: 'Execute plans with verification',

package/bin/lib/state.cjs

@@ -4,7 +4,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const CURRENT_SCHEMA = 'brain/v1';
-const CURRENT_VERSION = '0.8.0';
+const CURRENT_VERSION = '0.9.0';
 
 /**
  * Atomic write: write to temp file, then rename.
@@ -176,6 +176,11 @@ function migrateState(data) {
     migrated.phase.last_stuck_at = null;
   }
 
+  // v0.9.0 fields (new-task)
+  if (!migrated.tasks) {
+    migrated.tasks = { current: null, count: 0, active: [], history: [] };
+  }
+
   return migrated;
 }
 
@@ -320,6 +325,22 @@ function generateStateMd(state) {
     lines.push('');
   }
 
+  // Active Tasks section (v0.9.0)
+  if (state.tasks && state.tasks.active && state.tasks.active.length > 0) {
+    lines.push('');
+    lines.push('## Active Tasks');
+    for (const t of state.tasks.active) {
+      lines.push(`- Task ${t.num}: ${t.slug} (${t.status})`);
+    }
+  }
+  if (state.tasks && state.tasks.count > 0) {
+    lines.push('');
+    lines.push(`## Task Stats`);
+    lines.push(`- Total: ${state.tasks.count}`);
+    lines.push(`- Active: ${state.tasks.active ? state.tasks.active.length : 0}`);
+    lines.push(`- Completed: ${state.tasks.history ? state.tasks.history.length : 0}`);
+  }
+
   lines.push('## Blockers');
 
   if (Array.isArray(blockers) && blockers.length > 0) {
@@ -441,6 +462,12 @@ function createDefaultState(platform) {
       preinline: true,
       budgets: {},
       condensed_summaries: true
+    },
+    tasks: {
+      current: null,
+      count: 0,
+      active: [],
+      history: []
     }
   };
 }

package/commands/brain/new-task.md

@@ -0,0 +1,31 @@
+---
+name: brain:new-task
+description: Create a significant task with full discuss → plan → execute → verify → complete pipeline
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - Agent
+  - AskUserQuestion
+---
+<objective>
+Create and execute a significant task that needs thoughtful planning, execution, and verification.
+Unlike quick tasks, new-task applies the full pipeline. Unlike new-project, it works within the existing project context.
+</objective>
+
+<context>
+Use new-task for features, refactors, or epics that need more ceremony than a quick fix but less than a new project.
+Examples: "add payment integration", "refactor auth to JWT", "add rate limiting to API"
+</context>
+
+<process>
+1. Create: `npx brain-dev new-task "description"` [--research] [--light]
+2. Follow the step instructions output by the command
+3. After each step completes, run: `npx brain-dev new-task --continue`
+4. Pipeline: discuss → plan → execute → verify → complete
+5. On completion, optionally promote to roadmap: `npx brain-dev new-task --promote N`
+6. List tasks: `npx brain-dev new-task --list`
+</process>

package/hooks/bootstrap.sh

@@ -48,7 +48,7 @@ try {
     'Phase: ' + (data.phase && data.phase.current || 0) + ' (' + (data.phase && data.phase.status || 'initialized') + ')',
     'Next: ' + (data.nextAction || '/brain:new-project'),
     '',
-    'Commands: /brain:new-project, /brain:discuss, /brain:plan, /brain:execute, /brain:verify, /brain:complete, /brain:quick, /brain:progress, /brain:pause, /brain:resume, /brain:help, /brain:health, /brain:update, /brain:storm, /brain:adr, /brain:phase, /brain:config, /brain:map, /brain:recover, /brain:dashboard, /brain:auto (or execute --auto)',
+    'Commands: /brain:new-project, /brain:discuss, /brain:plan, /brain:execute, /brain:verify, /brain:complete, /brain:quick, /brain:new-task, /brain:progress, /brain:pause, /brain:resume, /brain:help, /brain:health, /brain:update, /brain:storm, /brain:adr, /brain:phase, /brain:config, /brain:map, /brain:recover, /brain:dashboard, /brain:auto (or execute --auto)',
     '',
     'Instructions for Claude:',
     '- When user types /brain:<command>, run: npx brain-dev <command> [args]',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brain-dev",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "AI-powered development workflow orchestrator",
   "author": "halilcosdu",
   "license": "MIT",