@mthanhlm/autodev 0.2.2 → 0.3.0

package/PUBLISH.md

@@ -26,7 +26,7 @@ npm pack
 Check the tarball contents:
 
 ```bash
-tar -tf mthanhlm-autodev-0.2.2.tgz
+tar -tf mthanhlm-autodev-$(node -p "require('./package.json').version").tgz
 ```
 
 ## First Public Publish

package/README.md

@@ -7,7 +7,7 @@
 - Installs a small Claude Code workflow under `~/.claude/` or `./.claude/`
 - Keeps project state in `.autodev/`
 - Uses `/autodev` as the main command
-- Organizes work as `project -> track -> phase`
+- Organizes work as `project -> track -> phase -> tasks`
 - Maps brownfield repos with four parallel codebase agents
 - Runs a four-agent review pass after execution
 - Ships manual commands when you want direct control:
@@ -59,12 +59,45 @@ Typical brownfield route:
 /autodev
   -> new project
   -> explore codebase
-  -> plan
-  -> execute
+  -> plan phase
+  -> execute next task
+  -> execute next task
   -> review
   -> verify
 ```
 
+## Workflow Model
+
+```text
+project -> track -> phase -> tasks
+```
+
+- `project`
+  The repo or product context.
+- `track`
+  One initiative stream.
+- `phase`
+  One milestone-sized slice inside a track.
+- `task`
+  One reviewable implementation unit inside a phase.
+
+### Why Tasks Exist Under A Phase
+
+- Large phases are too big for one uninterrupted execution context
+- Developers need control over what changes next
+- Each task can run in a fresh background agent context
+- The main `/autodev` session stays small and orchestration-focused
+
+### Execution Model
+
+- `/autodev` remains the single entrypoint
+- A phase is planned into one phase overview plus multiple task files
+- The phase keeps one user-facing orchestration session
+- Each task is executed by a fresh worker agent in the background
+- After each task, the worker reports back with files changed, verification, and blockers
+- No waves by default
+- No parallel execution unless the user explicitly asks for it later
+
 ## Git Policy
 
 `autodev` does not stage, commit, branch, merge, worktree, pull, push, or initialize git repositories. Read-only git commands like `git status`, `git diff`, and `git log` remain allowed.

package/agents/autodev-task-worker.md

@@ -0,0 +1,28 @@
+# autodev-task-worker
+
+Execute one assigned task inside the current phase and report back to the main phase session.
+
+## Goal
+
+- Read the assigned phase context and task file
+- Make only the code changes needed for that task
+- Run the requested verification
+- Write the matching task summary
+
+## Rules
+
+- You are not alone in the codebase.
+- Stay inside the assigned task scope.
+- Do not run git write commands.
+- Do not silently expand into the next task.
+- If blocked, say so clearly and write the blocker into the task summary.
+
+## Output
+
+- Update the repository code for the assigned task only.
+- Write only the assigned `TASK-NN-SUMMARY.md`.
+- Return a concise report:
+  - task id
+  - files changed
+  - verification run
+  - blocker or done

package/autodev/bin/autodev-tools.cjs

@@ -249,6 +249,98 @@ function phasePaths(cwd, slug, phase) {
   };
 }
 
+function readSingleLineField(content, label) {
+  if (!content) {
+    return null;
+  }
+  const match = content.match(new RegExp(`^${label}:\\s*(.+)$`, 'mi'));
+  return match ? match[1].trim() : null;
+}
+
+function parseTaskDependsOn(value) {
+  if (!value || /^none$/i.test(value)) {
+    return [];
+  }
+
+  return String(value)
+    .split(/[,\s]+/)
+    .map(part => part.trim())
+    .filter(Boolean)
+    .map(part => {
+      const match = part.match(/(\d+)/);
+      return match ? Number(match[1]) : null;
+    })
+    .filter(number => Number.isFinite(number));
+}
+
+function readTaskTitle(content, fallbackNumber) {
+  if (!content) {
+    return `Task ${String(fallbackNumber).padStart(2, '0')}`;
+  }
+
+  const heading = content.match(/^#\s+Task\s+\d+\s*:\s*(.+)$/mi);
+  if (heading) {
+    return heading[1].trim();
+  }
+
+  const generic = content.match(/^#\s+(.+)$/m);
+  return generic ? generic[1].trim() : `Task ${String(fallbackNumber).padStart(2, '0')}`;
+}
+
+function listTasksForPhaseDetails(phaseDetails) {
+  if (!phaseDetails || !fileExists(phaseDetails.dir)) {
+    return [];
+  }
+
+  const entries = fs.readdirSync(phaseDetails.dir, { withFileTypes: true })
+    .filter(entry => entry.isFile())
+    .map(entry => entry.name);
+
+  const tasks = entries
+    .map(name => {
+      const match = name.match(/^TASK-(\d+)\.md$/);
+      if (!match) {
+        return null;
+      }
+
+      const number = Number(match[1]);
+      const padded = String(number).padStart(2, '0');
+      const taskPath = path.join(phaseDetails.dir, name);
+      const summaryPath = path.join(phaseDetails.dir, `TASK-${padded}-SUMMARY.md`);
+      const content = readText(taskPath);
+      const status = readSingleLineField(content, 'Status') || 'pending';
+      const dependsOn = parseTaskDependsOn(readSingleLineField(content, 'Depends On'));
+      const summaryExists = fileExists(summaryPath);
+
+      return {
+        number,
+        padded,
+        title: readTaskTitle(content, number),
+        status,
+        dependsOn,
+        taskPath,
+        summaryPath,
+        summaryExists
+      };
+    })
+    .filter(Boolean)
+    .sort((left, right) => left.number - right.number);
+
+  const doneSet = new Set(tasks.filter(task => task.summaryExists).map(task => task.number));
+
+  return tasks.map(task => ({
+    ...task,
+    ready: !task.summaryExists && task.dependsOn.every(dep => doneSet.has(dep)),
+    effectiveStatus: task.summaryExists ? 'done' : task.status
+  }));
+}
+
+function nextExecutableTask(tasks) {
+  return tasks.find(task => !task.summaryExists && task.ready)
+    || tasks.find(task => !task.summaryExists)
+    || null;
+}
+
 function listPhases(cwd, slug = readActiveTrack(cwd)) {
   const track = trackPaths(cwd, slug);
   if (!track || !fileExists(track.roadmap)) {
@@ -261,12 +353,19 @@ function listPhases(cwd, slug = readActiveTrack(cwd)) {
     const summaryExists = fileExists(details.summaryPath);
     const reviewExists = fileExists(details.reviewPath);
     const uatExists = fileExists(details.uatPath);
+    const tasks = listTasksForPhaseDetails(details);
+    const taskCount = tasks.length;
+    const taskDoneCount = tasks.filter(task => task.summaryExists).length;
     const status = uatExists
       ? 'verified'
       : reviewExists
         ? 'reviewed'
         : summaryExists
           ? 'executed'
+          : planExists && taskCount > 0 && taskDoneCount === taskCount
+            ? 'tasks_complete'
+            : planExists && taskDoneCount > 0
+              ? 'executing'
           : planExists
             ? 'planned'
             : 'pending';
@@ -278,6 +377,9 @@ function listPhases(cwd, slug = readActiveTrack(cwd)) {
       summaryExists,
       reviewExists,
       uatExists,
+      taskCount,
+      taskDoneCount,
+      nextTask: nextExecutableTask(tasks)?.number || null,
       status
     };
   });
@@ -467,7 +569,9 @@ function buildProgress(cwd) {
       planned: phases.filter(phase => phase.planExists).length,
       executed: phases.filter(phase => phase.summaryExists).length,
       reviewed: phases.filter(phase => phase.reviewExists).length,
-      verified: phases.filter(phase => phase.uatExists).length
+      verified: phases.filter(phase => phase.uatExists).length,
+      tasks: phases.reduce((total, phase) => total + phase.taskCount, 0),
+      tasksDone: phases.reduce((total, phase) => total + phase.taskDoneCount, 0)
     },
     route,
     nextCommand: route.command,
@@ -492,16 +596,18 @@ function renderProgressTable(progress) {
     `Executed: ${progress.counts.executed}`,
     `Reviewed: ${progress.counts.reviewed}`,
     `Verified: ${progress.counts.verified}`,
+    `Tasks: ${progress.counts.tasks}`,
+    `Task Summaries: ${progress.counts.tasksDone}`,
     `Next: ${progress.route.command}`,
     progress.route.manualCommand ? `Manual Shortcut: ${progress.route.manualCommand}` : null,
     '',
-    '| Phase | Type | Name | Plan | Summary | Review | UAT | Status |',
-    '| --- | --- | --- | --- | --- | --- | --- | --- |'
+    '| Phase | Type | Name | Tasks | Done | Plan | Summary | Review | UAT | Status |',
+    '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |'
   ].filter(Boolean);
 
   for (const phase of progress.phases) {
     lines.push(
-      `| ${phase.number} | ${phase.type} | ${phase.name} | ${phase.planExists ? 'yes' : 'no'} | ${phase.summaryExists ? 'yes' : 'no'} | ${phase.reviewExists ? 'yes' : 'no'} | ${phase.uatExists ? 'yes' : 'no'} | ${phase.status} |`
+      `| ${phase.number} | ${phase.type} | ${phase.name} | ${phase.taskCount} | ${phase.taskDoneCount} | ${phase.planExists ? 'yes' : 'no'} | ${phase.summaryExists ? 'yes' : 'no'} | ${phase.reviewExists ? 'yes' : 'no'} | ${phase.uatExists ? 'yes' : 'no'} | ${phase.status} |`
     );
   }
 
@@ -598,6 +704,8 @@ function initPayload(cwd, mode, requestedPhase) {
   const track = trackPaths(cwd, activeTrack);
   const phaseMode = mode === 'review-phase' ? 'review' : mode === 'verify-work' ? 'verify' : mode === 'execute-phase' ? 'execute' : mode === 'plan-phase' ? 'plan' : null;
   const phase = phaseMode && activeTrack ? resolvePhase(cwd, activeTrack, requestedPhase, phaseMode) : null;
+  const tasks = phase ? listTasksForPhaseDetails(phase) : [];
+  const nextTask = nextExecutableTask(tasks);
   const codebase = codebasePaths(cwd);
 
   return {
@@ -641,6 +749,23 @@ function initPayload(cwd, mode, requestedPhase) {
     summary_exists: phase ? phase.summaryExists : false,
     review_exists: phase ? phase.reviewExists : false,
     uat_exists: phase ? phase.uatExists : false,
+    tasks_dir: phase ? phase.dir : null,
+    task_count: tasks.length,
+    task_done_count: tasks.filter(task => task.summaryExists).length,
+    all_tasks_done: tasks.length > 0 && tasks.every(task => task.summaryExists),
+    next_task_number: nextTask ? nextTask.number : null,
+    next_task_path: nextTask ? nextTask.taskPath : null,
+    next_task_summary_path: nextTask ? nextTask.summaryPath : null,
+    tasks: tasks.map(task => ({
+      number: task.number,
+      title: task.title,
+      status: task.effectiveStatus,
+      depends_on: task.dependsOn,
+      ready: task.ready,
+      task_path: task.taskPath,
+      summary_path: task.summaryPath,
+      summary_exists: task.summaryExists
+    })),
     workflow: config.workflow,
     git_mode: config.git.mode
   };
@@ -743,5 +868,7 @@ module.exports = {
   renderProgressTable,
   resolvePhase,
   rootPaths,
-  trackPaths
+  trackPaths,
+  listTasksForPhaseDetails,
+  nextExecutableTask
 };

package/autodev/templates/plan.md

@@ -13,17 +13,28 @@ Type: [feature|bugfix|refactor|research|polish]
 - ROADMAP.md
 - Current codebase state
 
-## Steps
-1. [Concrete task]
-2. [Concrete task]
+## Execution Model
+- This phase is executed through task files.
+- Keep one orchestration session for the phase.
+- Execute one task at a time.
+- No waves by default.
 
-## Files Likely To Change
-- [path]
+## Phase-Level Risks
+- [Risk]
 
-## Verification
+## Shared Verification
 - [Command]
 - [Manual check]
 
+## Task List
+| Task | Status | Depends On | Goal |
+| --- | --- | --- | --- |
+| 01 | pending | none | [Concrete task goal] |
+| 02 | pending | 01 | [Concrete task goal] |
+
+## Notes
+- [Anything the worker agents must know]
+
 ## Git Policy
 - Read-only only.
 - Allowed: `git status`, `git diff`, `git log`, `git show`, `git rev-parse`, `git ls-files`, `git branch --show-current`.

package/autodev/templates/project-state.md

@@ -3,6 +3,8 @@
 Project Type: [greenfield or brownfield]
 Active Track: [slug]
 Current Step: initialized
+Current Task: none
+Current Task Status: idle
 Status: active
 Next Command: /autodev
 Last Updated: [ISO timestamp]

package/autodev/templates/state.md

@@ -3,6 +3,8 @@
 Project Type: [greenfield or brownfield]
 Active Track: [slug]
 Current Step: initialized
+Current Task: none
+Current Task Status: idle
 Status: active
 Next Command: /autodev
 Last Updated: [ISO timestamp]

package/autodev/templates/summary.md

@@ -2,7 +2,11 @@
 
 Type: [feature|bugfix|refactor|research|polish]
 
-## Completed
+## Tasks Completed
+- Task 01 - [Outcome]
+- Task 02 - [Outcome]
+
+## Phase Outcome
 - [What shipped]
 
 ## Files Changed

package/autodev/templates/task-summary.md

@@ -0,0 +1,18 @@
+# Task [NN] Summary: [Name]
+
+Status: done
+
+## Completed
+- [What changed]
+
+## Files Changed
+- [path]
+
+## Verification
+- [Command and result]
+
+## Risks Or Follow-Up
+- [Risk or none]
+
+## Recommended Next Step
+- Return to `/autodev`

package/autodev/templates/task.md

@@ -0,0 +1,23 @@
+# Task [NN]: [Name]
+
+Status: pending
+Depends On: none
+
+## Goal
+[What this task accomplishes]
+
+## Why This Task Exists
+- [Why this should be a separate unit]
+
+## Files Likely To Change
+- [path]
+
+## Implementation Notes
+- [Concrete implementation guidance]
+
+## Verification
+- [Command]
+- [Manual check]
+
+## Done Looks Like
+- [Observable completion signal]

package/autodev/templates/track-state.md

@@ -4,6 +4,8 @@ Track: [Name]
 Current Phase: 1
 Current Phase Type: [feature]
 Current Step: planning
+Current Task: none
+Current Task Status: idle
 Status: active
 Next Command: /autodev
 Last Updated: [ISO timestamp]

package/autodev/workflows/autodev.md

@@ -5,7 +5,7 @@ Use `/autodev` as the single entrypoint for the normal workflow. Route automatic
 <rules>
 - Prefer `/autodev` over telling the user to run a different command manually.
 - Manual commands remain valid escape hatches. Mention them only as shortcuts.
-- Keep the model `project -> track -> phase`.
+- Keep the model `project -> track -> phase -> tasks`.
 - Brownfield repositories should be mapped before detailed phase planning.
 - Never run git write commands.
 </rules>
@@ -23,7 +23,7 @@ node "$HOME/.claude/autodev/bin/autodev-tools.cjs" status
    - `init_project`: perform the new-project workflow.
    - `explore_codebase`: perform the explore-codebase workflow.
    - `plan_phase`: perform the plan-phase workflow.
-   - `execute_phase`: perform the execute-phase workflow.
+   - `execute_phase`: perform the execute-phase workflow, which should advance one task-sized unit in the current phase session.
    - `review_phase`: perform the review-phase workflow.
    - `verify_phase`: perform the verify-work workflow.
 

package/autodev/workflows/execute-phase.md

@@ -1,12 +1,14 @@
 <purpose>
-Execute an active-track phase plan sequentially, keep the edits pragmatic, and capture the real outcome in a summary.
+Execute an active-track phase through task-sized worker runs, keep the main session orchestration-focused, and capture both task summaries and the final phase summary.
 </purpose>
 
 <rules>
 - Never run git write commands.
 - Do not create commits, branches, merges, or worktrees.
 - Stay within the current phase. Do not silently expand scope.
-- Execute sequentially by default. Do not create parallel sub-work unless the user explicitly asks for it.
+- Execute one task at a time by default.
+- Do not use waves.
+- Use a fresh background worker for each task so the phase session does not bloat.
 </rules>
 
 <process>
@@ -23,37 +25,77 @@ node "$HOME/.claude/autodev/bin/autodev-tools.cjs" init execute-phase "$ARGUMENT
    - `.autodev/tracks/<active-track>/STATE.md`
    - `.autodev/codebase/summary.md` if it exists
    - the target `NN-PLAN.md`
-   - the source files needed for the current phase
+   - all `TASK-*.md`
+   - all existing `TASK-*-SUMMARY.md`
 
-4. Execute the plan directly in the repository. Use normal coding tools, tests, and read-only git inspection if useful.
+4. If the phase has no `TASK-*.md` files:
+   - create `TASK-01.md` as a compatibility bridge from the current phase plan
+   - keep it narrow and explicit
+   - then continue
 
-5. Keep a short running note of:
-   - files changed
-   - commands run
-   - tests passed or failed
-   - any scope adjustments the user explicitly approved
+5. Determine the next executable task:
+   - prefer the first task without a summary whose dependencies are already done
+   - if no executable task remains and all task summaries exist, move to phase aggregation
+   - if task dependencies are inconsistent, stop and ask the user how to repair the plan
 
-6. Write or update `NN-SUMMARY.md` from the template with:
-   - completed work
-   - files changed
-   - verification results
-   - remaining risks
-   - next step
+6. Before running a task, show the user:
+   - task id and title
+   - likely files to touch
+   - verification plan
+   - any dependency note
 
-7. Update the active track `STATE.md` so it points to:
+7. Spawn one fresh background worker using `autodev-task-worker` for the selected task.
+   Tell it:
+   - phase path
+   - task path
+   - summary path to write
+   - required context files to read first
+   - to return a concise outcome only
+
+8. After the worker returns:
+   - confirm `TASK-NN-SUMMARY.md` exists
+   - inspect whether the task is done or blocked
+   - report the result to the user
+
+9. If more tasks remain:
+   - update project and track state to:
+     - `Current Step: execution`
+     - `Current Task: <next-task>`
+     - `Current Task Status: ready`
+     - `Next Command: /autodev`
+   - end by telling the user `/autodev` will continue with the next task
+
+10. If all tasks are done:
+   - write or update `NN-SUMMARY.md` from the template with:
+     - completed tasks
+     - aggregate files changed
+     - overall verification results
+     - remaining risks
+     - next step
+
+11. Update the active track `STATE.md` so it points to:
    - `Current Phase: N`
    - `Current Phase Type: <type>`
    - `Current Step: review`
+   - `Current Task: none`
+   - `Current Task Status: complete`
    - `Next Command: /autodev`
    - current ISO timestamp
 
-8. Update `.autodev/STATE.md` so it points to:
+12. Update `.autodev/STATE.md` so it points to:
    - `Active Track: <slug>`
    - `Current Step: review`
+   - `Current Task: none`
+   - `Current Task Status: complete`
    - `Next Command: /autodev`
    - current ISO timestamp
 
-9. If the phase is blocked or incomplete, say so clearly in the summary and set both state files back to `Current Step: execution`, with `Next Command: /autodev`.
+13. If the current task is blocked or incomplete:
+   - say so clearly in the task summary
+   - set both state files to `Current Step: execution`
+   - set `Current Task: <same-task>`
+   - set `Current Task Status: blocked`
+   - keep `Next Command: /autodev`
 
-10. End with a short outcome summary and the next recommended command. Mention that the automatic review bundle is the next routed step.
+14. End with a short outcome summary and the next recommended command. Mention that the automatic review bundle is the next routed step only when the whole phase is complete.
 </process>

package/autodev/workflows/help.md

@@ -16,9 +16,9 @@ Lean Claude Code workflow. No automatic commits. No branches. No worktrees. Git
 - `/autodev-explore-codebase`
   Spawns four parallel agents to map a brownfield repo into `.autodev/codebase/`.
 - `/autodev-plan-phase [phase]`
-  Creates or revises one phase plan in `.autodev/tracks/<track>/phases/NN-type-name/NN-PLAN.md`.
+  Creates or revises one phase plan plus task files in `.autodev/tracks/<track>/phases/NN-type-name/`.
 - `/autodev-execute-phase [phase]`
-  Executes one phase plan sequentially and writes `NN-SUMMARY.md`.
+  Orchestrates one phase task-by-task and writes `TASK-NN-SUMMARY.md` plus the final `NN-SUMMARY.md`.
 - `/autodev-review-phase [phase]`
   Spawns four review agents for code quality, security, integration, and polish, then writes `NN-REVIEW.md`.
 - `/autodev-verify-work [phase]`
@@ -31,7 +31,7 @@ Lean Claude Code workflow. No automatic commits. No branches. No worktrees. Git
 ## Workflow Model
 
 ```text
-project -> track -> phase
+project -> track -> phase -> tasks
 ```
 
 - `project`
@@ -39,7 +39,9 @@ project -> track -> phase
 - `track`
   The current initiative, feature line, refactor, or bugfix stream.
 - `phase`
-  Small execution slices inside the active track.
+  Small milestone slices inside the active track.
+- `task`
+  Reviewable execution units inside a phase.
 
 ## Default Flow
 

package/autodev/workflows/new-project.md

@@ -49,6 +49,8 @@ node "$HOME/.claude/autodev/bin/autodev-tools.cjs" init new-project
    - `Project Type: ...`
    - `Active Track: <slug>`
    - `Current Step: initialized`
+   - `Current Task: none`
+   - `Current Task Status: idle`
    - `Status: active`
    - `Next Command: /autodev`
    - current ISO timestamp
@@ -79,6 +81,8 @@ Each phase must include:
    - `Current Phase: 1`
    - `Current Phase Type: <type>`
    - `Current Step: planning`
+   - `Current Task: none`
+   - `Current Task Status: idle`
    - `Status: active`
    - `Next Command: /autodev`
    - current ISO timestamp

package/autodev/workflows/plan-phase.md

@@ -1,12 +1,14 @@
 <purpose>
-Create one practical phase plan for the active track. Keep it concrete, small enough to execute, and free of git-write steps.
+Create one practical phase plan for the active track, then break it into reviewable task files that are small enough for fresh worker-agent execution.
 </purpose>
 
 <rules>
 - One plan file per phase: `NN-PLAN.md`.
+- Use task files as the execution unit.
 - Prefer direct action over deep orchestration.
 - Optional research is allowed only when the user asks for it or `workflow.research` is true.
 - Never include git write commands in the plan.
+- Do not use waves by default.
 </rules>
 
 <process>
@@ -42,24 +44,52 @@ node "$HOME/.claude/autodev/bin/autodev-tools.cjs" init plan-phase "$ARGUMENTS"
 7. Write or replace `NN-PLAN.md` from the template. The plan must include:
    - phase type
    - goal
-   - concrete implementation steps
-   - likely files to touch
-   - verification commands
-   - manual checks
+   - shared verification commands
+   - task list overview
    - explicit git read-only reminder
 
-8. Update the active track `STATE.md` so it points to:
+8. Create task files in the same phase directory:
+
+```text
+TASK-01.md
+TASK-02.md
+...
+```
+
+Each task should be:
+   - small enough for one fresh worker agent context
+   - clear about likely files to touch
+   - explicit about verification
+   - reviewable as a standalone unit
+   - sequential by default unless there is an obvious safe dependency split
+
+Each task file must include:
+   - task title
+   - `Status: pending`
+   - `Depends On: ...`
+   - goal
+   - why it is separate
+   - files likely to change
+   - implementation notes
+   - verification
+   - done looks like
+
+9. Update the active track `STATE.md` so it points to:
    - `Current Phase: N`
    - `Current Phase Type: <type>`
    - `Current Step: planned`
+   - `Current Task: 01` if tasks exist, otherwise `none`
+   - `Current Task Status: ready`
    - `Next Command: /autodev`
    - current ISO timestamp
 
-9. Update `.autodev/STATE.md` so it points to:
+10. Update `.autodev/STATE.md` so it points to:
    - `Active Track: <slug>`
    - `Current Step: planned`
+   - `Current Task: 01` if tasks exist, otherwise `none`
+   - `Current Task Status: ready`
    - `Next Command: /autodev`
    - current ISO timestamp
 
-10. End with a short summary and direct the user to `/autodev`. Mention `/autodev-execute-phase N` as the manual shortcut.
+11. End with a short summary and direct the user to `/autodev`. Mention `/autodev-execute-phase N` as the manual shortcut.
 </process>

package/autodev/workflows/review-phase.md

@@ -22,6 +22,8 @@ node "$HOME/.claude/autodev/bin/autodev-tools.cjs" init review-phase "$ARGUMENTS
    - `.autodev/STATE.md`
    - the active track `STATE.md`
    - `NN-PLAN.md`
+   - all `TASK-*.md`
+   - all `TASK-*-SUMMARY.md`
    - `NN-SUMMARY.md`
    - relevant source files and tests
 

package/autodev/workflows/verify-work.md

@@ -19,6 +19,8 @@ node "$HOME/.claude/autodev/bin/autodev-tools.cjs" init verify-work "$ARGUMENTS"
 
 3. Read:
    - `NN-PLAN.md`
+   - all `TASK-*.md`
+   - all `TASK-*-SUMMARY.md`
    - `NN-SUMMARY.md`
    - `NN-REVIEW.md`
    - relevant code or UI files
@@ -40,6 +42,8 @@ node "$HOME/.claude/autodev/bin/autodev-tools.cjs" init verify-work "$ARGUMENTS"
    - if verification passed and another phase remains, move to the next phase and set `Current Step: planning`
    - if verification passed and no phase remains, set `Current Step: complete`
    - if verification failed, keep the same phase active and set `Current Step: execution`
+   - when moving to another phase, set `Current Task: none` and `Current Task Status: idle`
+   - when verification failed, set `Current Task: none` and `Current Task Status: idle`
    - always set `Next Command: /autodev`
    - always refresh the ISO timestamp
 

package/commands/autodev/execute-phase.md

@@ -1,6 +1,6 @@
 ---
 name: autodev:execute-phase
-description: Execute an active-track phase plan sequentially without git writes
+description: Execute an active-track phase task by task with fresh background workers and no git writes
 argument-hint: "[phase-number]"
 allowed-tools:
   - Read
@@ -11,14 +11,17 @@ allowed-tools:
   - Glob
   - TodoWrite
   - AskUserQuestion
+  - Task
 ---
 <objective>
-Execute one active-track phase plan and record the result in a summary.
+Execute one active-track phase through task-sized worker runs and record both task-level and phase-level summaries.
 </objective>
 
 <execution_context>
 @~/.claude/autodev/workflows/execute-phase.md
 @~/.claude/autodev/templates/summary.md
+@~/.claude/autodev/templates/task-summary.md
+@~/.claude/autodev/agents/autodev-task-worker.md
 </execution_context>
 
 <process>

package/commands/autodev/plan-phase.md

@@ -1,6 +1,6 @@
 ---
 name: autodev:plan-phase
-description: Create a practical plan for one phase in the active track roadmap
+description: Create a practical phase plan and break it into reviewable task files
 argument-hint: "[phase-number]"
 allowed-tools:
   - Read
@@ -12,12 +12,13 @@ allowed-tools:
   - WebFetch
 ---
 <objective>
-Create or update a single executable phase plan under the active track in `.autodev/tracks/<track>/phases/`.
+Create or update a single executable phase plan under the active track in `.autodev/tracks/<track>/phases/`, plus task files for controlled execution.
 </objective>
 
 <execution_context>
 @~/.claude/autodev/workflows/plan-phase.md
 @~/.claude/autodev/templates/plan.md
+@~/.claude/autodev/templates/task.md
 </execution_context>
 
 <process>

package/hooks/autodev-statusline.js

@@ -4,6 +4,41 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+function readStateFields(cwd) {
+  try {
+    let cursor = cwd;
+    let statePath = null;
+    while (cursor && cursor !== path.dirname(cursor)) {
+      const candidate = path.join(cursor, '.autodev', 'STATE.md');
+      if (fs.existsSync(candidate)) {
+        statePath = candidate;
+        break;
+      }
+      cursor = path.dirname(cursor);
+    }
+
+    if (!statePath) {
+      return {
+        currentTask: '',
+        currentTaskStatus: ''
+      };
+    }
+
+    const content = fs.readFileSync(statePath, 'utf8');
+    const currentTask = content.match(/^Current Task:\s*(.+)$/mi)?.[1]?.trim() || '';
+    const currentTaskStatus = content.match(/^Current Task Status:\s*(.+)$/mi)?.[1]?.trim() || '';
+    return {
+      currentTask: currentTask && currentTask !== 'none' ? currentTask : '',
+      currentTaskStatus: currentTaskStatus && currentTaskStatus !== 'idle' ? currentTaskStatus : ''
+    };
+  } catch {
+    return {
+      currentTask: '',
+      currentTaskStatus: ''
+    };
+  }
+}
+
 let input = '';
 const stdinTimeout = setTimeout(() => process.exit(0), 3000);
 process.stdin.setEncoding('utf8');
@@ -19,6 +54,7 @@ process.stdin.on('end', () => {
     const currentDir = data.workspace?.current_dir || process.cwd();
     const remaining = data.context_window?.remaining_percentage;
     const sessionId = data.session_id || '';
+    const taskState = readStateFields(currentDir);
 
     let contextLabel = '';
     if (typeof remaining === 'number') {
@@ -38,7 +74,11 @@ process.stdin.on('end', () => {
       }
     }
 
-    process.stdout.write(`${model} | ${path.basename(currentDir)}${contextLabel}`);
+    const taskLabel = taskState.currentTask
+      ? ` | task ${taskState.currentTask}${taskState.currentTaskStatus ? ` (${taskState.currentTaskStatus})` : ''}`
+      : '';
+
+    process.stdout.write(`${model} | ${path.basename(currentDir)}${taskLabel}${contextLabel}`);
   } catch {
     process.exit(0);
   }

package/hooks/autodev-workflow-guard.js

@@ -42,7 +42,7 @@ process.stdin.on('end', () => {
         hookEventName: 'PreToolUse',
         additionalContext:
           `WORKFLOW ADVISORY: you are editing ${path.basename(filePath)} outside .autodev state files. ` +
-          'If this belongs to the current phase, keep STATE.md and the phase summary aligned.'
+          'If this belongs to the current phase, keep STATE.md, task summaries, and the phase summary aligned.'
       }
     }));
   } catch {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mthanhlm/autodev",
-  "version": "0.2.2",
-  "description": "A lean Claude Code workflow system with a single entrypoint, brownfield codebase mapping, and read-only git.",
+  "version": "0.3.0",
+  "description": "A lean Claude Code workflow system with a single entrypoint, task-based phase execution, and read-only git.",
   "bin": {
     "autodev": "bin/install.js"
   },