@fermindi/pwn-cli 0.4.1 → 0.6.0

package/README.md

@@ -52,9 +52,9 @@ pwn notify test         # Test notification channels
 pwn notify send "msg"   # Send notification
 
 # Batch Execution
-pwn batch               # Execute next task
-pwn batch --count 5     # Execute 5 tasks
-pwn batch status        # Show progress
+pwn batch run            # Run autonomous batch loop
+pwn batch run --dry-run  # Preview next story
+pwn batch status         # Show progress
 
 # Patterns
 pwn patterns list       # List all patterns
@@ -85,7 +85,7 @@ your-project/
 │   │   └── deadends.md      # Failed approaches (DE-XXX)
 │   ├── tasks/
 │   │   ├── active.md        # Current work
-│   │   └── backlog.md       # Future work
+│   │   └── prd.json         # Stories (structured JSON)
 │   ├── patterns/
 │   │   ├── index.md         # Trigger mappings
 │   │   ├── frontend/        # React, Vue, etc.
@@ -142,17 +142,21 @@ decisions  tracking   patterns  cleanup
 
 ### Batch Execution
 
-Execute tasks autonomously:
+Execute stories autonomously via `batch_runner.sh`:
 
 ```bash
-pwn batch --count 5 --priority high
+./.ai/batch/batch_runner.sh              # Run batch loop
+./.ai/batch/batch_runner.sh --dry-run    # Preview next story
+pwn batch run --phase 3                  # Via CLI
 ```
 
 Features:
-- Quality gates (lint, test, typecheck)
-- Checkpoint-based pause/resume
-- Auto-commit after each task
-- Notifications on completion
+- Reads stories from `.ai/tasks/prd.json`
+- Quality gates (lint, test, typecheck) per task
+- Retry with error context (up to 2x)
+- Circuit breaker (3 consecutive failures)
+- Rate limit detection + auto-wait
+- Per-task logs in `logs/`
 
 ### Codespaces Integration
 

package/cli/batch.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { execSync } from 'child_process';
+import { join } from 'path';
 import * as batch from '../src/services/batch-service.js';
 import { hasWorkspace } from '../src/core/state.js';
 
@@ -27,6 +29,19 @@ export default async function batchCommand(args = []) {
     return showConfig();
   }
 
+  if (subcommand === 'run') {
+    const runnerPath = join(process.cwd(), '.ai', 'batch', 'batch_runner.sh');
+    try {
+      execSync(`bash ${runnerPath} ${args.slice(1).join(' ')}`, {
+        cwd: process.cwd(),
+        stdio: 'inherit'
+      });
+    } catch (error) {
+      process.exit(error.status || 1);
+    }
+    return;
+  }
+
   // Parse options
   const options = parseOptions(args);
 
@@ -109,12 +124,8 @@ function showStatus() {
   // Task counts
   console.log('\n📝 Tasks\n');
   console.log(`   Active: ${status.tasks.activePending} pending, ${status.tasks.activeCompleted} completed`);
-  console.log(`   Backlog: ${status.tasks.backlogTotal} total`);
-  if (status.tasks.backlogTotal > 0) {
-    console.log(`     - High: ${status.tasks.backlogHigh}`);
-    console.log(`     - Medium: ${status.tasks.backlogMedium}`);
-    console.log(`     - Low: ${status.tasks.backlogLow}`);
-  }
+  console.log(`   Stories: ${status.tasks.storiesDone}/${status.tasks.storiesTotal} done`);
+  console.log(`   Pending: ${status.tasks.storiesPending}`);
 
   // Batch history
   if (status.batchState?.completed?.length > 0) {
@@ -133,7 +144,7 @@ function showStatus() {
       console.log(`   Priority: ${nextTask.priority}`);
     }
   } else {
-    console.log('\n   No tasks available in backlog');
+    console.log('\n   No tasks available in prd.json');
   }
 }
 
@@ -185,7 +196,7 @@ async function dryRun(options) {
   }
 
   if (tasks.length === 0) {
-    console.log('   No tasks available in backlog');
+    console.log('   No tasks available in prd.json');
     return;
   }
 
@@ -305,6 +316,7 @@ function showHelp() {
   console.log('Usage: pwn batch [command] [options]\n');
   console.log('Commands:');
   console.log('  (default)              Execute next available task(s)');
+  console.log('  run                    Run batch_runner.sh (autonomous loop)');
   console.log('  status                 Show batch status');
   console.log('  config                 Show batch configuration\n');
   console.log('Options:');
@@ -320,11 +332,12 @@ function showHelp() {
   console.log('  --help, -h             Show this help\n');
   console.log('Examples:');
   console.log('  pwn batch                    # Execute next task');
+  console.log('  pwn batch run                # Run autonomous batch loop');
+  console.log('  pwn batch run --dry-run      # Preview next story');
+  console.log('  pwn batch run --phase 3      # Run specific phase');
   console.log('  pwn batch --count 5          # Execute 5 tasks');
   console.log('  pwn batch --dry-run          # Preview execution');
-  console.log('  pwn batch --priority high    # Only high priority');
   console.log('  pwn batch --resume           # Resume paused batch');
-  console.log('  pwn batch --resume --skip    # Resume, skip current');
   console.log('  pwn batch status             # Show status');
   console.log('  pwn batch config             # Show configuration\n');
   console.log('Configuration:');

package/cli/index.js

@@ -27,7 +27,7 @@ if (!command || command === '--help' || command === '-h') {
   console.log('  status              Show workspace status');
   console.log('  validate            Validate workspace structure');
   console.log('  notify              Send notifications (test, send, config)');
-  console.log('  batch               Execute tasks autonomously');
+  console.log('  batch               Execute tasks (batch run = autonomous loop)');
   console.log('  mode                Manage session mode (interactive/batch)');
   console.log('  patterns            Manage patterns and triggers');
   console.log('  knowledge           Knowledge lifecycle management');
@@ -41,7 +41,7 @@ if (!command || command === '--help' || command === '-h') {
   console.log('  save --message=X    Save with custom summary');
   console.log('  validate --verbose  Show detailed structure report');
   console.log('  notify test [ch]    Test notification channel');
-  console.log('  batch --count 5     Execute 5 tasks');
+  console.log('  batch run           Run autonomous batch loop');
   console.log('  mode batch --max-tasks=3  Configure batch mode');
   console.log('  patterns eval <f>   Evaluate triggers for file');
   console.log('  knowledge status    Show knowledge system status');

package/cli/inject.js

@@ -61,9 +61,10 @@ export default async function injectCommand(args = []) {
   console.log('📁 Created structure:');
   console.log('   .ai/');
   console.log('   ├── memory/         (decisions, patterns, dead-ends)');
-  console.log('   ├── tasks/          (active work, backlog)');
+  console.log('   ├── tasks/          (active work, prd.json)');
   console.log('   ├── patterns/       (auto-applied patterns)');
-  console.log('   ├── workflows/      (batch execution)');
+  console.log('   ├── batch/          (batch runner, prompts)
+   ├── workflows/      (batch execution)');
   console.log('   ├── agents/         (AI agent configs)');
   console.log('   └── config/         (notifications, etc)');
   console.log('   .claude/');

package/cli/migrate.js

@@ -300,7 +300,7 @@ function generateMigrationActions(parsed, cwd) {
 
   // Tasks
   if (parsed.tasks.length > 0) {
-    const targetPath = join(cwd, '.ai', 'tasks', 'backlog.md');
+    const targetPath = join(cwd, '.ai', 'tasks', 'active.md');
     let newContent = '\n## Migrated Tasks\n\n';
     for (const task of parsed.tasks) {
       newContent += task.replace(/^##\s+.+\n/, '') + '\n';
@@ -310,7 +310,7 @@ function generateMigrationActions(parsed, cwd) {
       type: 'append',
       target: targetPath,
       content: newContent,
-      description: `Add ${parsed.tasks.length} task section(s) to backlog.md`
+      description: `Add ${parsed.tasks.length} task section(s) to active.md`
     });
   }
 

package/cli/mode.js

@@ -71,7 +71,7 @@ function setBatchMode(args) {
     console.log('✅ Switched to batch mode (config reset to defaults)\n');
     console.log('Config:');
     printConfig(DEFAULT_BATCH_CONFIG);
-    console.log('\nRun \'pwn batch\' to start executing tasks from backlog.');
+    console.log('\nRun \'pwn batch run\' to start executing tasks from prd.json.');
     return;
   }
 
@@ -99,7 +99,7 @@ function setBatchMode(args) {
     printConfig(getBatchConfig());
   }
 
-  console.log('\nRun \'pwn batch\' to start executing tasks from backlog.');
+  console.log('\nRun \'pwn batch run\' to start executing tasks from prd.json.');
 }
 
 function parseConfigArgs(args) {

package/cli/status.js

@@ -29,7 +29,7 @@ export default async function statusCommand() {
   // Tasks summary
   console.log('📋 Tasks');
   console.log(`   Active:    ${info.tasks.active.pending} pending, ${info.tasks.active.completed} completed`);
-  console.log(`   Backlog:   ${info.tasks.backlog.total} items`);
+  console.log(`   Stories:   ${info.tasks.backlog.done || 0}/${info.tasks.backlog.total} done, ${info.tasks.backlog.pending || 0} pending`);
   console.log();
 
   // Memory summary

package/cli/update.js

@@ -2,6 +2,7 @@
 import { existsSync, readFileSync, writeFileSync, cpSync, renameSync, mkdirSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { convertBacklogToPrd } from '../src/services/batch-service.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -17,6 +18,10 @@ const FRAMEWORK_FILES = [
   'patterns/backend/backend.template.md',
   'patterns/universal/universal.template.md',
   'workflows/batch-task.md',
+  'batch/batch_runner.sh',
+  'batch/prompt.md',
+  'batch/progress.txt',
+  'batch/prd_status.sh',
   'config/README.md',
   'README.md',
 ];
@@ -39,7 +44,7 @@ const USER_FILES = [
   'memory/deadends.md',
   'memory/archive/',
   'tasks/active.md',
-  'tasks/backlog.md',
+  'tasks/prd.json',
   'state.json',
   'config/notifications.json',
 ];
@@ -122,6 +127,46 @@ export default async function updateCommand(args = []) {
   }
   // ============================================
 
+  // ============================================
+  // MIGRATION: backlog.md → prd.json
+  // Convert legacy backlog.md to structured prd.json
+  // ============================================
+  const backlogPath = join(aiDir, 'tasks', 'backlog.md');
+  const prdPath = join(aiDir, 'tasks', 'prd.json');
+
+  if (existsSync(backlogPath)) {
+    // Check if prd.json is missing or is the default template (empty stories)
+    let needsMigration = !existsSync(prdPath);
+    if (!needsMigration && existsSync(prdPath)) {
+      try {
+        const prd = JSON.parse(readFileSync(prdPath, 'utf8'));
+        needsMigration = !prd.stories || prd.stories.length === 0;
+      } catch {
+        needsMigration = true;
+      }
+    }
+
+    if (needsMigration) {
+      const backlogContent = readFileSync(backlogPath, 'utf8');
+      const prd = convertBacklogToPrd(backlogContent);
+
+      if (prd.stories.length > 0) {
+        if (dryRun) {
+          console.log(`   🔄 Would migrate: .ai/tasks/backlog.md → prd.json (${prd.stories.length} stories)`);
+          console.log(`   📦 Would backup: backlog.md → ~backlog.md`);
+        } else {
+          writeFileSync(prdPath, JSON.stringify(prd, null, 2));
+          renameSync(backlogPath, join(aiDir, 'tasks', '~backlog.md'));
+          console.log(`   🔄 Migrated: backlog.md → prd.json (${prd.stories.length} stories)`);
+          console.log(`   📦 Backed up: backlog.md → .ai/tasks/~backlog.md`);
+          backed_up.push('backlog.md');
+        }
+        updated.push('tasks/backlog.md → prd.json');
+      }
+    }
+  }
+  // ============================================
+
   // Update framework files in .ai/
   for (const file of FRAMEWORK_FILES) {
     const templateFile = join(templateDir, file);
@@ -166,13 +211,12 @@ export default async function updateCommand(args = []) {
     if (templateContent !== currentContent) {
       if (dryRun) {
         console.log(`   📝 Would update: CLAUDE.md`);
-        // Only mention backup if content is actually different (not empty)
-        if (currentContent && currentContent !== templateContent) {
+        if (currentContent) {
           console.log(`   📦 Would backup: CLAUDE.md → ~CLAUDE.md`);
         }
       } else {
-        // Backup existing CLAUDE.md only if it has custom content (different from template)
-        if (existsSync(claudeMdPath) && currentContent && currentContent !== templateContent) {
+        // Backup existing CLAUDE.md
+        if (existsSync(claudeMdPath) && currentContent) {
           renameSync(claudeMdPath, backupClaudeMdPath);
           console.log(`   📦 Backed up: CLAUDE.md → ~CLAUDE.md`);
           backed_up.push('CLAUDE.md');
@@ -273,7 +317,7 @@ export default async function updateCommand(args = []) {
   // Show what was preserved
   console.log('🔒 Preserved (user data):');
   console.log('   .ai/memory/     (decisions, patterns, deadends)');
-  console.log('   .ai/tasks/      (active, backlog)');
+  console.log('   .ai/tasks/      (active, prd.json)');
   console.log('   .ai/state.json  (session state)');
   console.log('   .claude/        (your custom commands preserved)\n');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fermindi/pwn-cli",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Professional AI Workspace - Inject structured memory and automation into any project for AI-powered development",
   "type": "module",
   "bin": {

package/src/core/inject.js

@@ -3,6 +3,7 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { randomUUID } from 'crypto';
 import { initState } from './state.js';
+import { convertBacklogToPrd } from '../services/batch-service.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -147,6 +148,20 @@ export async function inject(options = {}) {
     }
   }
 
+  // Migrate backlog.md → prd.json before overwriting (force path)
+  let migratedPrd = null;
+  if (force) {
+    const backlogPath = join(targetDir, 'tasks', 'backlog.md');
+    if (existsSync(backlogPath)) {
+      const backlogContent = readFileSync(backlogPath, 'utf8');
+      const prd = convertBacklogToPrd(backlogContent);
+      if (prd.stories.length > 0) {
+        migratedPrd = prd;
+        log(`🔄 Detected backlog.md with ${prd.stories.length} stories, will convert to prd.json`);
+      }
+    }
+  }
+
   try {
     // Copy workspace template
     log('📦 Copying workspace template...');
@@ -172,31 +187,33 @@ export async function inject(options = {}) {
     // Initialize state.json with current user
     initState(cwd);
 
+    // Write migrated prd.json (from backlog.md) if available
+    if (migratedPrd) {
+      const prdPath = join(targetDir, 'tasks', 'prd.json');
+      writeFileSync(prdPath, JSON.stringify(migratedPrd, null, 2));
+      log(`📝 Created prd.json from backlog.md (${migratedPrd.stories.length} stories)`);
+    }
+
     // Update .gitignore
     updateGitignore(cwd, silent);
 
-    // Handle CLAUDE.md: backup existing (only if different) and copy PWN template to root
+    // Handle CLAUDE.md: backup existing and copy PWN template to root
     let backupInfo = { backed_up: [] };
     const claudeMdPath = join(cwd, 'CLAUDE.md');
     const backupClaudeMdPath = join(cwd, '~CLAUDE.md');
     const templateClaudeMd = join(targetDir, 'agents', 'claude.md');
-    const templateContent = existsSync(templateClaudeMd) ? readFileSync(templateClaudeMd, 'utf8') : '';
 
-    // Backup existing CLAUDE.md if present AND different from template
+    // Backup existing CLAUDE.md if present
     if (backedUpContent['CLAUDE.md'] || backedUpContent['claude.md']) {
       const originalName = backedUpContent['CLAUDE.md'] ? 'CLAUDE.md' : 'claude.md';
       const originalPath = join(cwd, originalName);
-      const existingContent = backedUpContent[originalName]?.content || '';
 
-      // Only backup if content is different from PWN template
-      if (existsSync(originalPath) && existingContent !== templateContent) {
+      if (existsSync(originalPath)) {
         renameSync(originalPath, backupClaudeMdPath);
         backupInfo.backed_up.push({ from: originalName, to: '~CLAUDE.md' });
         if (!silent) {
           console.log(`📦 Backed up ${originalName} → ~CLAUDE.md`);
         }
-      } else if (existsSync(originalPath) && !silent) {
-        console.log(`⏭️  Skipped backup: ${originalName} is identical to PWN template`);
       }
     }
 

package/src/core/validate.js

@@ -24,7 +24,13 @@ const REQUIRED_STRUCTURE = {
   ],
   taskFiles: [
     'tasks/active.md',
-    'tasks/backlog.md'
+    'tasks/prd.json'
+  ],
+  batchFiles: [
+    'batch/batch_runner.sh',
+    'batch/prompt.md',
+    'batch/progress.txt',
+    'batch/prd_status.sh'
   ],
   agentFiles: [
     'agents/README.md',
@@ -88,6 +94,14 @@ export function validate(cwd = process.cwd()) {
     }
   }
 
+  // Check batch files
+  for (const file of REQUIRED_STRUCTURE.batchFiles) {
+    const filePath = join(aiDir, file);
+    if (!existsSync(filePath)) {
+      warnings.push(`Missing batch file: .ai/${file}`);
+    }
+  }
+
   // Check agent files
   for (const file of REQUIRED_STRUCTURE.agentFiles) {
     const filePath = join(aiDir, file);
@@ -189,6 +203,7 @@ export function getStructureReport(cwd = process.cwd()) {
     ...REQUIRED_STRUCTURE.files,
     ...REQUIRED_STRUCTURE.memoryFiles,
     ...REQUIRED_STRUCTURE.taskFiles,
+    ...REQUIRED_STRUCTURE.batchFiles,
     ...REQUIRED_STRUCTURE.agentFiles,
     ...REQUIRED_STRUCTURE.patternFiles
   ];

package/src/core/workspace.js

@@ -39,11 +39,11 @@ export function getWorkspaceInfo(cwd = process.cwd()) {
  */
 function getTasksSummary(cwd) {
   const activePath = join(cwd, '.ai', 'tasks', 'active.md');
-  const backlogPath = join(cwd, '.ai', 'tasks', 'backlog.md');
+  const prdPath = join(cwd, '.ai', 'tasks', 'prd.json');
 
   const summary = {
     active: { total: 0, completed: 0, pending: 0 },
-    backlog: { total: 0 }
+    backlog: { total: 0, done: 0, pending: 0 }
   };
 
   // Parse active.md
@@ -63,15 +63,17 @@ function getTasksSummary(cwd) {
     }
   }
 
-  // Parse backlog.md
-  if (existsSync(backlogPath)) {
-    const content = readFileSync(backlogPath, 'utf8');
-    const lines = content.split('\n');
-
-    for (const line of lines) {
-      if (line.match(/^- \[[ ]\]/) || line.match(/^\d+\./)) {
-        summary.backlog.total++;
-      }
+  // Parse prd.json
+  if (existsSync(prdPath)) {
+    try {
+      const prd = JSON.parse(readFileSync(prdPath, 'utf8'));
+      summary.backlog = {
+        total: prd.stories.length,
+        done: prd.stories.filter(s => s.passes).length,
+        pending: prd.stories.filter(s => !s.passes).length
+      };
+    } catch {
+      // Invalid JSON, leave defaults
     }
   }
 

package/src/services/batch-service.js

@@ -125,19 +125,26 @@ export function parseActiveTasks(cwd = process.cwd()) {
 }
 
 /**
- * Parse tasks from backlog.md
+ * Parse stories from prd.json
  * @param {string} cwd - Working directory
- * @returns {Array<object>} Array of tasks
+ * @returns {Array<object>} Array of stories
  */
-export function parseBacklogTasks(cwd = process.cwd()) {
-  const backlogPath = join(cwd, '.ai', 'tasks', 'backlog.md');
-
-  if (!existsSync(backlogPath)) {
+export function parsePrdTasks(cwd = process.cwd()) {
+  const prdPath = join(cwd, '.ai', 'tasks', 'prd.json');
+  if (!existsSync(prdPath)) return [];
+  try {
+    const prd = JSON.parse(readFileSync(prdPath, 'utf8'));
+    return prd.stories || [];
+  } catch {
     return [];
   }
+}
 
-  const content = readFileSync(backlogPath, 'utf8');
-  return parseBacklogFromMarkdown(content);
+/**
+ * @deprecated Use parsePrdTasks instead
+ */
+export function parseBacklogTasks(cwd = process.cwd()) {
+  return parsePrdTasks(cwd);
 }
 
 /**
@@ -257,16 +264,36 @@ function parseBacklogFromMarkdown(content) {
 }
 
 /**
- * Select next task to execute based on strategy
+ * Convert backlog.md content to prd.json format
+ * @param {string} backlogContent - Raw markdown content from backlog.md
+ * @param {string} projectName - Project name for prd.json
+ * @returns {object} PRD JSON structure
+ */
+export function convertBacklogToPrd(backlogContent, projectName = 'my-project') {
+  const tasks = parseBacklogFromMarkdown(backlogContent);
+  return {
+    project: projectName,
+    branch: "main",
+    stories: tasks.map(t => ({
+      id: t.id,
+      title: t.title,
+      phase: t.section ? `Phase ${t.section}` : "Phase 1",
+      effort: t.effort || "M",
+      dependencies: t.dependencies ? t.dependencies.split(',').map(d => d.trim()) : [],
+      passes: false,
+      acceptance_criteria: [],
+      notes: t.description || ""
+    }))
+  };
+}
+
+/**
+ * Select next task to execute based on prd.json dependencies
  * @param {string} cwd - Working directory
  * @param {object} options - Selection options
  * @returns {object|null} Selected task or null
  */
 export function selectNextTask(cwd = process.cwd(), options = {}) {
-  const config = loadConfig(cwd);
-  const strategy = options.strategy || config.selection_strategy;
-  const priorityFilter = options.priority;
-
   // First check active tasks for incomplete ones
   const activeTasks = parseActiveTasks(cwd);
   const pendingActive = activeTasks.filter(t => !t.completed && !t.blockedBy);
@@ -275,47 +302,40 @@ export function selectNextTask(cwd = process.cwd(), options = {}) {
     return pendingActive[0];
   }
 
-  // Then check backlog
-  let backlogTasks = parseBacklogTasks(cwd);
+  // Then check prd.json stories
+  const stories = parsePrdTasks(cwd);
+  const doneIds = stories.filter(s => s.passes).map(s => s.id);
 
-  // Filter by priority if specified
-  if (priorityFilter) {
-    backlogTasks = backlogTasks.filter(t => t.priority === priorityFilter);
-  }
-
-  // Filter out blocked tasks
-  backlogTasks = backlogTasks.filter(t => !t.dependencies || t.dependencies === 'None');
-
-  if (backlogTasks.length === 0) {
-    return null;
-  }
+  const eligible = stories.find(s =>
+    !s.passes &&
+    s.dependencies.every(dep => doneIds.includes(dep)) &&
+    (!options.phase || s.phase === options.phase)
+  );
 
-  // Sort based on strategy
-  switch (strategy) {
-    case 'effort':
-      // Sort by effort (smallest first)
-      const effortOrder = { 'XS': 1, 'S': 2, 'M': 3, 'L': 4, 'XL': 5 };
-      backlogTasks.sort((a, b) => {
-        const aEffort = effortOrder[a.effort] || 3;
-        const bEffort = effortOrder[b.effort] || 3;
-        return aEffort - bEffort;
-      });
-      break;
+  return eligible || null;
+}
 
-    case 'priority':
-    default:
-      // Sort by priority (highest first), then by position
-      const priorityOrder = { 'high': 1, 'medium': 2, 'low': 3 };
-      backlogTasks.sort((a, b) => {
-        const aPriority = priorityOrder[a.priority] || 2;
-        const bPriority = priorityOrder[b.priority] || 2;
-        if (aPriority !== bPriority) return aPriority - bPriority;
-        return a.line - b.line;
-      });
-      break;
+/**
+ * Mark a story as done in prd.json
+ * @param {string} taskId - Story ID
+ * @param {string} cwd - Working directory
+ * @returns {boolean} Success
+ */
+export function markStoryDone(taskId, cwd = process.cwd()) {
+  const prdPath = join(cwd, '.ai', 'tasks', 'prd.json');
+  if (!existsSync(prdPath)) return false;
+  try {
+    const prd = JSON.parse(readFileSync(prdPath, 'utf8'));
+    const story = prd.stories.find(s => s.id === taskId);
+    if (story) {
+      story.passes = true;
+      writeFileSync(prdPath, JSON.stringify(prd, null, 2));
+      return true;
+    }
+  } catch {
+    // Invalid JSON
   }
-
-  return backlogTasks[0];
+  return false;
 }
 
 /**
@@ -598,10 +618,12 @@ export function getStatus(cwd = process.cwd()) {
   const config = loadConfig(cwd);
   const batchState = getBatchState(cwd);
   const activeTasks = parseActiveTasks(cwd);
-  const backlogTasks = parseBacklogTasks(cwd);
+  const stories = parsePrdTasks(cwd);
 
   const pendingActive = activeTasks.filter(t => !t.completed);
   const completedActive = activeTasks.filter(t => t.completed);
+  const doneStories = stories.filter(s => s.passes);
+  const pendingStories = stories.filter(s => !s.passes);
 
   return {
     hasWorkspace: true,
@@ -611,10 +633,11 @@ export function getStatus(cwd = process.cwd()) {
       activeTotal: activeTasks.length,
       activePending: pendingActive.length,
       activeCompleted: completedActive.length,
-      backlogTotal: backlogTasks.length,
-      backlogHigh: backlogTasks.filter(t => t.priority === 'high').length,
-      backlogMedium: backlogTasks.filter(t => t.priority === 'medium').length,
-      backlogLow: backlogTasks.filter(t => t.priority === 'low').length
+      storiesTotal: stories.length,
+      storiesDone: doneStories.length,
+      storiesPending: pendingStories.length,
+      // Legacy compat
+      backlogTotal: stories.length
     },
     isRunning: batchState?.status === 'running',
     isPaused: batchState?.status === 'paused',

package/templates/workspace/.ai/agents/claude.md

@@ -71,10 +71,10 @@ If this is your first session:
    - Blocked items and blockers
    - Priority ordering
 
-2. **`/.ai/tasks/backlog.md`** (if needed)
-   - Future work not yet started
+2. **`/.ai/tasks/prd.json`** (if needed)
+   - Future work as structured JSON stories
    - Use when no active work assigned
-   - Pick highest priority unblocked item
+   - Pick next story with dependencies satisfied
 
 3. **Project-specific notes** (if applicable)
    - Check `/CLAUDE.md` in project root
@@ -268,110 +268,41 @@ When completing work:
 
 ## Batch Mode
 
-When `session_mode` is "batch" (autonomous task execution):
+Autonomous task execution via `.ai/batch/batch_runner.sh`.
 
-### Your Role
-- Execute tasks from backlog autonomously
-- Follow quality gates strictly
-- Make conservative decisions (ask user when uncertain)
-- Commit and push changes automatically
-- Continue until backlog depleted or limits reached
-
-### Batch Workflow
+The runner reads stories from `.ai/tasks/prd.json`, spawns fresh Claude sessions
+per task, runs quality gates, and tracks progress.
 
+### Usage
+```bash
+./.ai/batch/batch_runner.sh --dry-run    # Preview next task
+./.ai/batch/batch_runner.sh              # Run (default 20 iterations)
+./.ai/batch/batch_runner.sh 50           # Custom iteration limit
+./.ai/batch/batch_runner.sh --phase 3    # Specific phase only
 ```
-1. Read tasks/active.md
-   ├─ If incomplete tasks: resume work
-   └─ If no active tasks: read backlog.md
-
-2. Select highest-priority unblocked task
-   ├─ Check dependencies
-   ├─ Verify not blocked
-   └─ Move to tasks/active.md
-
-3. Create feature branch
-   └─ Name: feature/{task-id}-{slug}
-
-4. Execute work following patterns
-   ├─ Auto-apply triggers from patterns/index.md
-   ├─ Keep commits atomic and descriptive
-   └─ Test incrementally
-
-5. Quality gates must pass
-   ├─ If gate fails:
-   │  ├─ Attempt auto-fix if pattern known
-   │  ├─ Pause batch if can't fix
-   │  └─ Notify user
-   └─ If all pass: proceed to commit
-
-6. Commit and push
-   ├─ Stage all changes
-   ├─ Commit with conventional format
-   ├─ Push to origin
-   └─ Create PR if configured
-
-7. Clean up and continue
-   ├─ Delete local feature branch
-   ├─ Update tasks/active.md
-   ├─ Check if more tasks to execute
-   └─ Continue or stop
-
-8. Completion report
-   └─ Show summary: tasks done, time spent, any issues
-```
-
-### Batch Configuration
-
-Read from `/.ai/state.json`:
 
-```json
-{
-  "batch_config": {
-    "max_tasks": 5,
-    "max_duration_hours": 4,
-    "quality_gates": ["typecheck", "lint", "test"],
-    "skip_gates": [],
-    "auto_commit": true,
-    "auto_push": false,
-    "create_pr": false,
-    "branch_format": "feature/{id}-{slug}",
-    "commit_format": "conventional"
-  }
-}
-```
+### State Files
+| File | Purpose |
+|------|---------|
+| .ai/tasks/prd.json | Single source of truth for task status |
+| .ai/batch/progress.txt | Append-only operational learnings |
+| .ai/batch/prompt.md | Prompt template for Claude sessions |
+| logs/ | Per-task Claude output logs |
 
-**Important:** Batch mode is conservative:
-- Don't skip quality gates without explicit config
-- Ask user if uncertain about task interpretation
-- Stop on first blocker and notify user
-- Don't force push or destructive operations
-- Log all decisions and timing
-
-### Batch Error Handling
-
-**Build/Test Fails:**
-- Show error with full context
-- If pattern known: auto-fix
-- If unsure: pause and notify user
-- Don't proceed without resolution
-
-**Git Conflicts:**
-- Stop immediately
-- Notify user of conflict
-- Require manual resolution
-- Resume after conflict resolved
-
-**Missing Dependencies:**
-- Check if dependency task exists
-- Add to batch queue if available
-- Execute dependency first
-- Resume original task
-
-**Resource Limits Reached:**
-- Stop execution gracefully
-- Report progress
-- Create clean state for next batch
-- Notify user of completion status
+### How It Works
+1. Read prd.json → find next incomplete story (deps satisfied)
+2. Spawn: `claude --print --dangerously-skip-permissions -p "implement story X"`
+3. Run quality gates (configurable per project)
+4. If pass → mark story done in prd.json, commit
+5. If fail → retry up to 2x with error context
+6. Append learnings to progress.txt
+7. Repeat until done or max iterations
+
+### Safety
+- Circuit breaker: 3 consecutive failures → stop
+- Rate limit detection + auto-wait
+- Graceful Ctrl+C shutdown
+- Per-task logs for debugging
 
 ---
 
@@ -400,7 +331,7 @@ Reference these files in this priority order:
    - Project changelog or git history
 
 5. **Fifth Priority: Planning**
-   - `/.ai/tasks/backlog.md` - Future work
+   - `/.ai/tasks/prd.json` - Future work (structured)
    - Roadmap or project documentation
    - Upstream issues or features
 

package/templates/workspace/.ai/tasks/active.md

@@ -70,7 +70,7 @@ Highlight 1-3 most important tasks for today.
 
 ## Notes
 
-- Check backlog.md for upcoming work
+- Check prd.json for upcoming stories
 - Move completed tasks to archive or backlog with completion date
 - When stuck, create SPIKE task to investigate
 - Reference decisions from `memory/decisions.md`

package/templates/workspace/.ai/workflows/batch-task.md

@@ -4,103 +4,79 @@ This file defines the template for autonomous batch task execution via the `pwn
 
 ## Overview
 
-Batch task execution allows AI agents to autonomously:
-- Select tasks from backlog
-- Execute work in sequence
+Batch task execution uses `.ai/batch/batch_runner.sh` to autonomously:
+- Read stories from `.ai/tasks/prd.json`
+- Spawn fresh Claude sessions per task
 - Run quality gates (tests, linting, type checking)
-- Commit changes following conventions
-- Continue until backlog depleted or threshold reached
+- Track progress and learnings between iterations
+- Handle retries, rate limits, and circuit breaking
 
 ## Usage
 
 ```bash
-# Execute next available task
-pwn batch
+# Preview next task
+./.ai/batch/batch_runner.sh --dry-run
 
-# Execute specific number of tasks
-pwn batch --count 5
+# Run batch (default 20 iterations)
+./.ai/batch/batch_runner.sh
 
-# Dry-run: show what would execute
-pwn batch --dry-run
+# Custom iteration limit
+./.ai/batch/batch_runner.sh 50
 
-# Execute with specific priority
-pwn batch --priority high
+# Specific phase only
+./.ai/batch/batch_runner.sh --phase 3
 
-# Resume interrupted batch
-pwn batch --resume
+# Via pwn CLI
+pwn batch run
+pwn batch run --dry-run
+pwn batch status
 ```
 
 ## Batch Execution Protocol
 
 ### Phase 1: Task Selection
 
-1. Read `tasks/active.md` for incomplete tasks
-2. If active tasks exist and not blocked, resume
-3. Otherwise, read `tasks/backlog.md`
-4. Select highest priority unblocked task
-5. Verify dependencies are met
-6. Move to `active.md`
+1. Read `tasks/prd.json` for stories
+2. Find next story where `passes == false`
+3. Verify all dependencies have `passes == true`
+4. Apply phase filter if specified
 
 ### Phase 2: Execution
 
-1. Analyze task requirements
-2. Create feature branch: `feature/[task-id]-[slug]`
-3. Execute work following patterns in `patterns/index.md`
-4. Test incrementally during development
-5. Keep commits atomic and descriptive
+1. Build prompt from `.ai/batch/prompt.md` template
+2. Substitute story placeholders ({STORY_ID}, {STORY_TITLE}, etc.)
+3. Spawn: `claude --print --dangerously-skip-permissions -p "<prompt>"`
+4. Capture output to `logs/` for debugging
 
 ### Phase 3: Quality Gates
 
-Before commit, verify:
+Customize `run_quality_gates()` in `batch_runner.sh` for your stack:
 
+**Node.js:**
 ```bash
-# Type checking
-[ ] npm run typecheck || tsc --noEmit
-
-# Linting
-[ ] npm run lint || eslint .
-
-# Unit tests
-[ ] npm run test || jest
-
-# Integration tests (if applicable)
-[ ] npm run test:integration
-
-# Build verification
-[ ] npm run build
+npm test
+npm run lint
+npm run typecheck
+```
 
-# Security scan (if configured)
-[ ] npm run security
+**Python:**
+```bash
+pytest --tb=short
+ruff check src/
+mypy src/ --ignore-missing-imports
 ```
 
 **Gate Strategy:**
 - Fail fast on first error
-- Output clear error message
-- Suggest fix if known
-- Option to skip non-critical gates with `--force`
-
-### Phase 4: Commit & Cleanup
-
-1. Stage all changes: `git add .`
-2. Commit with message format:
-   ```
-   feat: [task-id] - [description]
-
-   - Specific change 1
-   - Specific change 2
-
-   Fixes: [task-id]
-   ```
-3. Push to remote: `git push -u origin feature/[task-id]-[slug]`
-4. Create PR if configured
-5. Update `active.md`: mark complete with date
+- Retry up to 2x with error context fed back to Claude
+- Circuit breaker after 3 consecutive failures
 
-### Phase 5: Completion
+### Phase 4: Completion
 
-1. Verify commit is on remote
-2. Delete local feature branch
-3. Report completion to user
-4. Continue to next task or stop
+1. Mark story as `passes: true` in prd.json
+2. Append learnings to `progress.txt`
+3. Commit prd.json + progress.txt update
+4. Continue to next story
 
 ## Batch Configuration
 

package/templates/workspace/.claude/commands/mode.md

@@ -77,10 +77,10 @@ pwn mode interactive
 
 ### Batch Mode
 
-- Claude executes tasks autonomously from backlog
-- Creates feature branches per task
+- Claude executes stories autonomously from prd.json
+- Spawns fresh sessions per task via batch_runner.sh
 - Runs quality gates before committing
-- Continues until backlog empty or limits reached
+- Retries with error context, circuit breaker on failures
 - Good for repetitive tasks and overnight execution
 
 ---
@@ -94,9 +94,10 @@ After executing the command, explain to the user:
 3. **Next steps** - What they can do next
 
 For batch mode, remind them:
-- Add tasks to `.ai/tasks/backlog.md`
-- Run `pwn batch` to start executing tasks
+- Add stories to `.ai/tasks/prd.json`
+- Run `pwn batch run` to start the batch runner
 - Use `pwn batch status` to check progress
+- Use `.ai/batch/prd_status.sh` for detailed PRD view
 
 For interactive mode, remind them:
 - Work proceeds conversationally

package/templates/workspace/.claude/settings.json

@@ -2,11 +2,20 @@
   "hooks": {
     "Notification": [
       {
-        "matcher": "",
+        "matcher": "permission_prompt",
         "hooks": [
           {
             "type": "command",
-            "command": "pwn notify send \"Claude Code aguardando permissao\" --title \"PWN\""
+            "command": "pwn notify send \"Claude Code aguardando permissão\" --title \"PWN\""
+          }
+        ]
+      },
+      {
+        "matcher": "idle_prompt",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "pwn notify send \"Claude Code aguardando input\" --title \"PWN\""
           }
         ]
       }

package/templates/workspace/.ai/tasks/backlog.md

@@ -1,95 +0,0 @@
-# Backlog
-
-This file contains prioritized future tasks not yet in active work.
-
-## Format
-
-Tasks are listed in priority order (highest to lowest):
-
-```markdown
-### US-XXX: Task Title
-**Type:** Story | Bug | DevTask
-**Priority:** High | Medium | Low
-**Effort:** (T-shirt size: XS, S, M, L, XL)
-**Description:** What needs to be done
-**Acceptance Criteria:**
-- [ ] Criterion 1
-- [ ] Criterion 2
-**Dependencies:** (Other tasks needed first)
-**Notes:** Context, caveats, research needed
-```
-
----
-
-## Moving to Active
-
-When starting a backlog task:
-
-1. Create issue/ticket in your tracking system
-2. Move to `active.md` with checkbox
-3. Assign team member
-4. Update priority based on sprint plan
-5. Reference in commit messages
-
----
-
-## Adding New Tasks
-
-When new work is identified:
-
-1. Assign next ID (US-XXX, BUG-XXX, etc.)
-2. Add to appropriate section
-3. Fill in all fields
-4. Don't assign yet - wait for planning
-5. Commit with message: `docs: add [ID] to backlog`
-
----
-
-## Backlog Sections
-
-### High Priority
-Work that should start soon. Review weekly.
-
-### Medium Priority
-Important but can wait. Review biweekly.
-
-### Low Priority
-Nice-to-have improvements. Review monthly.
-
-### Roadmap (Future Phases)
-Longer-term projects for future planning.
-
----
-
-## Template for New Backlog Item
-
-```markdown
-### US-XXX: [Title]
-**Type:** Story | Bug | DevTask
-**Priority:** High | Medium | Low
-**Effort:** S/M/L
-**Description:** (What and why)
-**Acceptance Criteria:**
-- [ ] (Specific, measurable outcome)
-**Dependencies:** (Other tasks)
-**Notes:** (Research, concerns, constraints)
-```
-
----
-
-## Management Guidelines
-
-- Groom backlog every sprint (remove duplicates, clarify)
-- Estimate effort using relative sizing (XS, S, M, L, XL)
-- Link related tasks together
-- Archive completed items with date + time spent
-- Keep description brief - link to external tickets for details
-
----
-
-## Cleanup
-
-- Remove or update duplicates
-- Close blocked items after 30 days of no progress
-- Archive completed items to `completed/` section
-- Re-estimate if context changes significantly