@e0ipso/ai-task-manager 1.18.5 → 1.18.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e0ipso/ai-task-manager",
-  "version": "1.18.5",
+  "version": "1.18.7",
   "description": "Task management for AI coding assistants",
   "main": "dist/index.js",
   "bin": {

package/templates/ai-task-manager/config/scripts/get-approval-methods.cjs

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Enable debug logging via environment variable
+const DEBUG = process.env.DEBUG === 'true';
+
+/**
+ * Debug logging utility
+ * @param {string} message - Debug message
+ * @param {...any} args - Additional arguments to log
+ */
+function debugLog(message, ...args) {
+  if (DEBUG) {
+    console.error(`[DEBUG] ${message}`, ...args);
+  }
+}
+
+/**
+ * Error logging utility
+ * @param {string} message - Error message
+ * @param {...any} args - Additional arguments to log
+ */
+function errorLog(message, ...args) {
+  console.error(`[ERROR] ${message}`, ...args);
+}
+
+/**
+ * Find the task manager root directory by traversing up from current working directory
+ * @returns {string|null} Path to task manager root or null if not found
+ */
+function findTaskManagerRoot() {
+  let currentPath = process.cwd();
+  const filesystemRoot = path.parse(currentPath).root;
+
+  debugLog(`Starting search for task manager root from: ${currentPath}`);
+
+  while (currentPath !== filesystemRoot) {
+    const taskManagerPlansPath = path.join(currentPath, '.ai', 'task-manager', 'plans');
+    debugLog(`Checking for task manager at: ${taskManagerPlansPath}`);
+
+    try {
+      if (fs.existsSync(taskManagerPlansPath)) {
+        const stats = fs.lstatSync(taskManagerPlansPath);
+        if (stats.isDirectory()) {
+          const taskManagerRoot = path.join(currentPath, '.ai', 'task-manager');
+          debugLog(`Found valid task manager root at: ${taskManagerRoot}`);
+          return taskManagerRoot;
+        }
+      }
+    } catch (err) {
+      debugLog(`Filesystem error checking ${taskManagerPlansPath}: ${err.message}`);
+    }
+
+    const parentPath = path.dirname(currentPath);
+    if (parentPath === currentPath) {
+      break;
+    }
+
+    currentPath = parentPath;
+  }
+
+  debugLog(`Task manager root not found in any parent directory`);
+  return null;
+}
+
+/**
+ * Find plan file by ID in plans or archive directories
+ * @param {string} taskManagerRoot - Path to task manager root
+ * @param {string} planId - Plan ID to find
+ * @returns {string|null} Path to plan file or null if not found
+ */
+function findPlanFile(taskManagerRoot, planId) {
+  const plansDir = path.join(taskManagerRoot, 'plans');
+  const archiveDir = path.join(taskManagerRoot, 'archive');
+
+  debugLog(`Searching for plan ${planId} in ${plansDir} and ${archiveDir}`);
+
+  for (const dir of [plansDir, archiveDir]) {
+    if (!fs.existsSync(dir)) {
+      debugLog(`Directory does not exist: ${dir}`);
+      continue;
+    }
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.match(/^\d+--/)) {
+          // Check if directory matches plan ID
+          const dirMatch = entry.name.match(/^(\d+)--/);
+          if (dirMatch && dirMatch[1] === planId) {
+            const planDirPath = path.join(dir, entry.name);
+            debugLog(`Found plan directory: ${planDirPath}`);
+
+            // Look for plan file inside directory
+            try {
+              const planDirEntries = fs.readdirSync(planDirPath, { withFileTypes: true });
+
+              for (const planEntry of planDirEntries) {
+                if (planEntry.isFile() && planEntry.name.match(/^plan-\d+--.*\.md$/)) {
+                  const planFilePath = path.join(planDirPath, planEntry.name);
+                  debugLog(`Found plan file: ${planFilePath}`);
+                  return planFilePath;
+                }
+              }
+            } catch (err) {
+              debugLog(`Failed to read plan directory ${planDirPath}: ${err.message}`);
+            }
+          }
+        } else if (entry.isFile() && entry.name.match(/^plan-\d+--.*\.md$/)) {
+          // Legacy: direct plan file in plans/archive directory
+          const filenameMatch = entry.name.match(/^plan-(\d+)--/);
+          if (filenameMatch && filenameMatch[1] === planId) {
+            const planFilePath = path.join(dir, entry.name);
+            debugLog(`Found legacy plan file: ${planFilePath}`);
+            return planFilePath;
+          }
+        }
+      }
+    } catch (err) {
+      errorLog(`Failed to read directory ${dir}: ${err.message}`);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract a field value from YAML frontmatter
+ * @param {string} frontmatter - YAML frontmatter text
+ * @param {string} fieldName - Field name to extract
+ * @param {string} defaultValue - Default value if field not found
+ * @returns {string} Field value or default
+ */
+function extractField(frontmatter, fieldName, defaultValue = 'manual') {
+  debugLog(`Extracting field: ${fieldName}`);
+
+  // Pattern to match field with various formatting:
+  // - field: value
+  // - field: "value"
+  // - field: 'value'
+  // - "field": value
+  // - field : value (extra spaces)
+  const regex = new RegExp(`^\\s*["']?${fieldName}["']?\\s*:\\s*(.+)$`, 'm');
+  const match = frontmatter.match(regex);
+
+  if (!match) {
+    debugLog(`Field ${fieldName} not found, using default: ${defaultValue}`);
+    return defaultValue;
+  }
+
+  // Clean up value: remove quotes and trim
+  let value = match[1].trim();
+  value = value.replace(/^['"]|['"]$/g, '');
+
+  debugLog(`Extracted ${fieldName}: ${value}`);
+  return value || defaultValue;
+}
+
+/**
+ * Main function to get approval methods from plan file
+ */
+function main() {
+  // Get plan ID from command line
+  const planId = process.argv[2];
+  if (!planId) {
+    errorLog('Error: Plan ID is required');
+    console.error('Usage: node get-approval-methods.cjs <plan-id>');
+    process.exit(1);
+  }
+
+  debugLog(`Looking for plan ID: ${planId}`);
+
+  // Find task manager root
+  const taskManagerRoot = findTaskManagerRoot();
+  if (!taskManagerRoot) {
+    errorLog('No .ai/task-manager directory found in current directory or any parent directory.');
+    errorLog('Please ensure you are in a project with task manager initialized.');
+    errorLog(`Current working directory: ${process.cwd()}`);
+    process.exit(1);
+  }
+
+  // Find plan file
+  const planFile = findPlanFile(taskManagerRoot, planId);
+  if (!planFile) {
+    errorLog(`Plan file for ID ${planId} not found in plans or archive directories.`);
+    process.exit(1);
+  }
+
+  debugLog(`Reading plan file: ${planFile}`);
+
+  // Read plan file
+  let content;
+  try {
+    content = fs.readFileSync(planFile, 'utf8');
+  } catch (err) {
+    errorLog(`Failed to read plan file ${planFile}: ${err.message}`);
+    process.exit(1);
+  }
+
+  // Extract YAML frontmatter
+  const frontmatterRegex = /^---\s*\r?\n([\s\S]*?)\r?\n---/;
+  const match = content.match(frontmatterRegex);
+
+  if (!match) {
+    errorLog('No YAML frontmatter found in plan file');
+    process.exit(1);
+  }
+
+  const frontmatter = match[1];
+  debugLog(`Found frontmatter:\n${frontmatter}`);
+
+  // Extract approval method fields
+  const approvalMethodPlan = extractField(frontmatter, 'approval_method_plan');
+  const approvalMethodTasks = extractField(frontmatter, 'approval_method_tasks');
+
+  // Output JSON
+  const result = {
+    approval_method_plan: approvalMethodPlan,
+    approval_method_tasks: approvalMethodTasks
+  };
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// Run main function
+main();

package/templates/ai-task-manager/config/scripts/validate-plan-blueprint.cjs

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Enable debug logging via environment variable
+const DEBUG = process.env.DEBUG === 'true';
+
+/**
+ * Debug logging utility
+ * @param {string} message - Debug message
+ * @param {...any} args - Additional arguments to log
+ */
+function debugLog(message, ...args) {
+  if (DEBUG) {
+    console.error(`[DEBUG] ${message}`, ...args);
+  }
+}
+
+/**
+ * Error logging utility
+ * @param {string} message - Error message
+ * @param {...any} args - Additional arguments to log
+ */
+function errorLog(message, ...args) {
+  console.error(`[ERROR] ${message}`, ...args);
+}
+
+/**
+ * Find the task manager root directory by traversing up from current working directory
+ * @returns {string|null} Path to task manager root or null if not found
+ */
+function findTaskManagerRoot() {
+  let currentPath = process.cwd();
+  const filesystemRoot = path.parse(currentPath).root;
+
+  debugLog(`Starting search for task manager root from: ${currentPath}`);
+  debugLog(`Filesystem root: ${filesystemRoot}`);
+
+  while (currentPath !== filesystemRoot) {
+    const taskManagerPlansPath = path.join(currentPath, '.ai', 'task-manager', 'plans');
+    debugLog(`Checking for task manager at: ${taskManagerPlansPath}`);
+
+    try {
+      if (fs.existsSync(taskManagerPlansPath)) {
+        const stats = fs.lstatSync(taskManagerPlansPath);
+        if (stats.isDirectory()) {
+          const taskManagerRoot = path.join(currentPath, '.ai', 'task-manager');
+          debugLog(`Found valid task manager root at: ${taskManagerRoot}`);
+          return taskManagerRoot;
+        } else {
+          debugLog(`Path exists but is not a directory: ${taskManagerPlansPath}`);
+        }
+      } else {
+        debugLog(`Task manager path does not exist: ${taskManagerPlansPath}`);
+      }
+    } catch (err) {
+      if (err.code === 'EPERM' || err.code === 'EACCES') {
+        const warningMsg = `Warning: Permission denied accessing ${taskManagerPlansPath}`;
+        console.warn(warningMsg);
+        debugLog(`Permission error: ${err.message}`);
+      } else {
+        debugLog(`Filesystem error checking ${taskManagerPlansPath}: ${err.message}`);
+      }
+    }
+
+    const parentPath = path.dirname(currentPath);
+
+    if (parentPath === currentPath) {
+      debugLog(`Reached filesystem root, stopping traversal`);
+      break;
+    }
+
+    currentPath = parentPath;
+    debugLog(`Moving up to parent directory: ${currentPath}`);
+  }
+
+  debugLog(`Task manager root not found in any parent directory`);
+  return null;
+}
+
+/**
+ * Find plan file and directory for a given plan ID
+ * @param {string|number} planId - Plan ID to search for
+ * @returns {Object|null} Object with planFile and planDir, or null if not found
+ */
+function findPlanById(planId) {
+  const taskManagerRoot = findTaskManagerRoot();
+
+  if (!taskManagerRoot) {
+    errorLog('No .ai/task-manager directory found in current directory or any parent directory.');
+    return null;
+  }
+
+  debugLog(`Task manager root found: ${taskManagerRoot}`);
+
+  const plansDir = path.join(taskManagerRoot, 'plans');
+  const archiveDir = path.join(taskManagerRoot, 'archive');
+
+  debugLog(`Searching for plan ID ${planId} in: ${plansDir}, ${archiveDir}`);
+
+  // Search both plans and archive directories
+  for (const dir of [plansDir, archiveDir]) {
+    if (!fs.existsSync(dir)) {
+      debugLog(`Directory does not exist: ${dir}`);
+      continue;
+    }
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      debugLog(`Found ${entries.length} entries in ${dir}`);
+
+      for (const entry of entries) {
+        // Match directory pattern: [plan-id]--*
+        if (entry.isDirectory() && entry.name.match(new RegExp(`^${planId}--`))) {
+          const planDirPath = path.join(dir, entry.name);
+          debugLog(`Found matching plan directory: ${planDirPath}`);
+
+          try {
+            const planDirEntries = fs.readdirSync(planDirPath, { withFileTypes: true });
+
+            // Look for plan file: plan-[plan-id]--*.md
+            for (const planEntry of planDirEntries) {
+              if (planEntry.isFile() && planEntry.name.match(new RegExp(`^plan-${planId}--.*\\.md$`))) {
+                const planFilePath = path.join(planDirPath, planEntry.name);
+                debugLog(`Found plan file: ${planFilePath}`);
+
+                return {
+                  planFile: planFilePath,
+                  planDir: planDirPath
+                };
+              }
+            }
+
+            debugLog(`No plan file found in directory: ${planDirPath}`);
+          } catch (err) {
+            errorLog(`Failed to read plan directory ${planDirPath}: ${err.message}`);
+          }
+        }
+      }
+    } catch (err) {
+      errorLog(`Failed to read directory ${dir}: ${err.message}`);
+    }
+  }
+
+  debugLog(`Plan ID ${planId} not found in any directory`);
+  return null;
+}
+
+/**
+ * Count task files in a plan's tasks directory
+ * @param {string} planDir - Plan directory path
+ * @returns {number} Number of task files found
+ */
+function countTasks(planDir) {
+  const tasksDir = path.join(planDir, 'tasks');
+
+  if (!fs.existsSync(tasksDir)) {
+    debugLog(`Tasks directory does not exist: ${tasksDir}`);
+    return 0;
+  }
+
+  try {
+    const stats = fs.lstatSync(tasksDir);
+    if (!stats.isDirectory()) {
+      debugLog(`Tasks path exists but is not a directory: ${tasksDir}`);
+      return 0;
+    }
+
+    const files = fs.readdirSync(tasksDir).filter(f => f.endsWith('.md'));
+    debugLog(`Found ${files.length} task files in ${tasksDir}`);
+    return files.length;
+  } catch (err) {
+    errorLog(`Failed to read tasks directory ${tasksDir}: ${err.message}`);
+    return 0;
+  }
+}
+
+/**
+ * Check if execution blueprint section exists in plan file
+ * @param {string} planFile - Path to plan file
+ * @returns {boolean} True if blueprint section exists, false otherwise
+ */
+function checkBlueprintExists(planFile) {
+  try {
+    const planContent = fs.readFileSync(planFile, 'utf8');
+    const blueprintExists = /^## Execution Blueprint/m.test(planContent);
+    debugLog(`Blueprint section ${blueprintExists ? 'found' : 'not found'} in ${planFile}`);
+    return blueprintExists;
+  } catch (err) {
+    errorLog(`Failed to read plan file ${planFile}: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * List available plans for error messaging
+ * @returns {string[]} Array of plan directory names
+ */
+function listAvailablePlans() {
+  const taskManagerRoot = findTaskManagerRoot();
+
+  if (!taskManagerRoot) {
+    return [];
+  }
+
+  const plansDir = path.join(taskManagerRoot, 'plans');
+  const archiveDir = path.join(taskManagerRoot, 'archive');
+  const plans = [];
+
+  for (const dir of [plansDir, archiveDir]) {
+    if (!fs.existsSync(dir)) {
+      continue;
+    }
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.match(/^\d+--/)) {
+          plans.push(entry.name);
+        }
+      }
+    } catch (err) {
+      // Silently continue
+    }
+  }
+
+  return plans.sort((a, b) => {
+    const aId = parseInt(a.match(/^(\d+)--/)[1], 10);
+    const bId = parseInt(b.match(/^(\d+)--/)[1], 10);
+    return aId - bId;
+  });
+}
+
+/**
+ * Validate plan blueprint and output JSON
+ * @param {string|number} planId - Plan ID to validate
+ */
+function validatePlanBlueprint(planId) {
+  if (!planId) {
+    errorLog('Plan ID is required');
+    errorLog('');
+    errorLog('Usage: node validate-plan-blueprint.cjs <plan-id>');
+    errorLog('');
+    errorLog('Example:');
+    errorLog('  node validate-plan-blueprint.cjs 47');
+    process.exit(1);
+  }
+
+  debugLog(`Validating plan blueprint for ID: ${planId}`);
+
+  const planInfo = findPlanById(planId);
+
+  if (!planInfo) {
+    errorLog(`Plan ID ${planId} not found`);
+    errorLog('');
+
+    const availablePlans = listAvailablePlans();
+    if (availablePlans.length > 0) {
+      errorLog('Available plans:');
+      availablePlans.forEach(plan => {
+        errorLog(`  ${plan}`);
+      });
+    } else {
+      errorLog('No plans found in .ai/task-manager/{plans,archive}/');
+    }
+
+    errorLog('');
+    errorLog('Please verify:');
+    errorLog('  1. You are in the correct project directory');
+    errorLog('  2. The plan exists in .ai/task-manager/plans/ or .ai/task-manager/archive/');
+    errorLog('  3. The plan directory follows the naming pattern: [plan-id]--[name]');
+    errorLog('  4. The plan file follows the naming pattern: plan-[plan-id]--[name].md');
+    process.exit(1);
+  }
+
+  const { planFile, planDir } = planInfo;
+  const taskCount = countTasks(planDir);
+  const blueprintExists = checkBlueprintExists(planFile);
+
+  const result = {
+    planFile,
+    planDir,
+    taskCount,
+    blueprintExists
+  };
+
+  debugLog('Validation complete:', result);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// Main execution
+const planId = process.argv[2];
+validatePlanBlueprint(planId);

package/templates/ai-task-manager/config/templates/PLAN_TEMPLATE.md

@@ -2,7 +2,8 @@
 id: [PLAN-ID]
 summary: "[Brief one-line description of what this plan accomplishes]"
 created: [YYYY-MM-DD]
-approval_method: [auto|manual]  # Optional: Workflow approval mode (auto=automated, manual=requires review)
+approval_method_plan: [auto|manual]  # Workflow approval for plan review (default: manual)
+approval_method_tasks: [auto|manual]  # Workflow approval for task generation review (default: manual)
 ---
 
 # Plan: [Descriptive Plan Title]

package/templates/assistant/commands/tasks/create-plan.md

@@ -88,14 +88,18 @@ Structure your response as follows:
 - If context is insufficient: List specific clarifying questions
 - If context is sufficient: Provide the comprehensive plan using the structure above. Use the information in @TASK_MANAGER.md for the directory structure and additional information about plans.
 
-**Output Behavior:**
+**Output Behavior: CRITICAL - Structured Output for Command Coordination**
 
-Be extremely concise but helpful:
-- Tell the user that you are done
-- Instruct them to review the plan document with the file path
-- Example output: "Plan created. Please review: `.ai/task-manager/plans/40--plan-name/plan-40--plan-name.md`"
+Always end your output with a standardized summary in this exact format:
 
-**Note:** When this command is invoked by the full-workflow command, the full-workflow will modify the plan's `approval_method` field after creation to enable automated execution.
+```
+---
+Plan Summary:
+- Plan ID: [numeric-id]
+- Plan File: [full-path-to-plan-file]
+```
+
+This structured output enables automated workflow coordination and must be included even when running standalone.
 
 ###### Plan Template
 
@@ -114,11 +118,12 @@ Example:
 id: 1
 summary: "Implement a comprehensive CI/CD pipeline using GitHub Actions for automated linting, testing, semantic versioning, and NPM publishing"
 created: 2025-09-01
-approval_method: "manual"
+approval_method_plan: "manual"
+approval_method_tasks: "manual"
 ---
 ```
 
-**Important**: Always set `approval_method` to "manual" when creating a plan. The full-workflow command will modify this field to "auto" after creation if running in automated mode.
+**Important**: Always set both `approval_method_plan` and `approval_method_tasks` to "manual" when creating a plan. The full-workflow command will modify these fields to "auto" after creation if running in automated mode.
 
 The schema for this frontmatter is:
 ```json
@@ -139,10 +144,15 @@ The schema for this frontmatter is:
       "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
       "description": "Creation date in YYYY-MM-DD format"
     },
-    "approval_method": {
+    "approval_method_plan": {
+      "type": "string",
+      "enum": ["auto", "manual"],
+      "description": "Workflow approval mode for plan review: auto for automated workflows, manual for standalone execution"
+    },
+    "approval_method_tasks": {
       "type": "string",
       "enum": ["auto", "manual"],
-      "description": "Workflow approval mode: auto for automated workflows, manual for standalone execution"
+      "description": "Workflow approval mode for task generation review: auto when tasks auto-generated in workflow, manual for standalone execution"
     }
   },
   "additionalProperties": false

package/templates/assistant/commands/tasks/execute-blueprint.md

@@ -45,22 +45,15 @@ Before proceeding with execution, validate that tasks exist and the execution bl
 
 **Validation Steps:**
 
-1. **Locate the plan document**:
 ```bash
-PLAN_FILE=$(find .ai/task-manager/{plans,archive} -name "plan-[0-9][0-9]*--*.md" -type f -exec grep -l "^id: \?$1$" {} \;)
-PLAN_DIR=$(dirname "$PLAN_FILE")
-```
-
-2. **Check for task files**:
-```bash
-setopt null_glob 2>/dev/null || true
-TASK_FILES=(${PLAN_DIR}/tasks/*.md)
-TASK_COUNT=${#TASK_FILES[@]}
-```
-
-3. **Check for execution blueprint section**:
-```bash
-BLUEPRINT_EXISTS=$(grep -q "^## Execution Blueprint" "$PLAN_FILE" && echo "yes" || echo "no")
+# Validate plan exists and check for tasks/blueprint
+VALIDATION=$(node .ai/task-manager/config/scripts/validate-plan-blueprint.cjs $1)
+
+# Parse validation results
+PLAN_FILE=$(echo "$VALIDATION" | grep -o '"planFile": "[^"]*"' | cut -d'"' -f4)
+PLAN_DIR=$(echo "$VALIDATION" | grep -o '"planDir": "[^"]*"' | cut -d'"' -f4)
+TASK_COUNT=$(echo "$VALIDATION" | grep -o '"taskCount": [0-9]*' | awk '{print $2}')
+BLUEPRINT_EXISTS=$(echo "$VALIDATION" | grep -o '"blueprintExists": [a-z]*' | awk '{print $2}')
 ```
 
 4. **Automatic task generation**:
@@ -71,7 +64,12 @@ If either `$TASK_COUNT` is 0 or `$BLUEPRINT_EXISTS` is "no":
    ```
    /tasks:generate-tasks $1
    ```
-   - **CRITICAL**: After task generation completes successfully, you MUST immediately proceed with blueprint execution without waiting for user input. The workflow should continue seamlessly.
+   - **NEW STEP**: Immediately after task generation succeeds, set the approval_method_tasks field to auto:
+     ```bash
+     node .ai/task-manager/config/scripts/set-approval-method.cjs "$PLAN_FILE" auto tasks
+     ```
+   - This signals that tasks were auto-generated in workflow context and execution should continue without pause.
+   - **CRITICAL**: After setting the field, you MUST immediately proceed with blueprint execution without waiting for user input. The workflow should continue seamlessly.
    - If generation fails: Halt execution with clear error message:
      ```
      ❌ Error: Automatic task generation failed.
@@ -146,33 +144,56 @@ Read and execute .ai/task-manager/config/hooks/POST_ERROR_DETECTION.md
 
 **Extract approval method from plan metadata:**
 
-First, extract the approval_method from the plan document:
+First, extract both approval method fields from the plan document:
 
 ```bash
-# Find plan file by ID
-PLAN_FILE=$(find .ai/task-manager/{plans,archive} -name "plan-$1--*.md" -type f -exec grep -l "^id: \?$1$" {} \;)
+# Extract approval methods from plan metadata
+APPROVAL_METHODS=$(node .ai/task-manager/config/scripts/get-approval-methods.cjs $1)
 
-# Extract approval_method from YAML frontmatter
-APPROVAL_METHOD=$(sed -n '/^---$/,/^---$/p' "$PLAN_FILE" | grep '^approval_method:' | sed 's/approval_method: *//;s/"//g;s/'"'"'//g' | tr -d ' ')
+APPROVAL_METHOD_PLAN=$(echo "$APPROVAL_METHODS" | grep -o '"approval_method_plan": "[^"]*"' | cut -d'"' -f4)
+APPROVAL_METHOD_TASKS=$(echo "$APPROVAL_METHODS" | grep -o '"approval_method_tasks": "[^"]*"' | cut -d'"' -f4)
 
-# Default to "manual" if field doesn't exist (backward compatibility)
-APPROVAL_METHOD=${APPROVAL_METHOD:-manual}
+# Defaults to "manual" if fields don't exist
+APPROVAL_METHOD_PLAN=${APPROVAL_METHOD_PLAN:-manual}
+APPROVAL_METHOD_TASKS=${APPROVAL_METHOD_TASKS:-manual}
 ```
 
-Then adjust output based on the extracted approval method:
+Then adjust output based on the extracted approval methods:
 
-- **If `APPROVAL_METHOD="auto"` (automated workflow mode)**:
-  - Provide minimal progress updates at phase boundaries
-  - Do NOT instruct user to review implementation details
+- **If `APPROVAL_METHOD_PLAN="auto"` (automated workflow mode)**:
+  - During task auto-generation phase: Provide minimal progress updates
+  - Do NOT instruct user to review the plan or tasks being generated
   - Do NOT add any prompts that would pause execution
+
+- **If `APPROVAL_METHOD_TASKS="auto"` (tasks auto-generated in workflow)**:
+  - During task execution phase: Provide minimal progress updates at phase boundaries
+  - Do NOT instruct user to review implementation details
   - Example output: "Phase 1/3 completed. Proceeding to Phase 2."
 
-- **If `APPROVAL_METHOD="manual"` or empty (standalone mode)**:
+- **If `APPROVAL_METHOD_PLAN="manual"` or `APPROVAL_METHOD_TASKS="manual"` (standalone mode)**:
   - Provide detailed execution summary with phase results
   - List completed tasks and any noteworthy events
   - Instruct user to review the execution summary in the plan document
   - Example output: "Execution completed. Review summary: `.ai/task-manager/archive/[plan]/plan-[id].md`"
 
+**Note**: This command respects both approval method fields:
+- `approval_method_plan`: Used during auto-generation to determine if we're in automated workflow
+- `approval_method_tasks`: Used during execution to determine output verbosity
+
+**CRITICAL - Structured Output for Command Coordination:**
+
+Always end your output with a standardized summary in this exact format:
+
+```
+---
+Execution Summary:
+- Plan ID: [numeric-id]
+- Status: Archived
+- Location: .ai/task-manager/archive/[plan-id]--[plan-name]/
+```
+
+This structured output enables automated workflow coordination and must be included even when running standalone.
+
 ## Optimization Guidelines
 
 - **Maximize parallelism**: Always run all available tasks in a phase simultaneously

package/templates/assistant/commands/tasks/generate-tasks.md

@@ -303,26 +303,39 @@ Read and run the .ai/task-manager/config/hooks/POST_TASK_GENERATION_ALL.md
 First, extract the approval_method from the plan document:
 
 ```bash
-# Find plan file by ID
-PLAN_FILE=$(find .ai/task-manager/{plans,archive} -name "plan-$1--*.md" -type f -exec grep -l "^id: \?$1$" {} \;)
+# Extract approval method from plan metadata
+APPROVAL_METHODS=$(node .ai/task-manager/config/scripts/get-approval-methods.cjs $1)
 
-# Extract approval_method from YAML frontmatter
-APPROVAL_METHOD=$(sed -n '/^---$/,/^---$/p' "$PLAN_FILE" | grep '^approval_method:' | sed 's/approval_method: *//;s/"//g;s/'"'"'//g' | tr -d ' ')
+APPROVAL_METHOD_TASKS=$(echo "$APPROVAL_METHODS" | grep -o '"approval_method_tasks": "[^"]*"' | cut -d'"' -f4)
 
 # Default to "manual" if field doesn't exist (backward compatibility)
-APPROVAL_METHOD=${APPROVAL_METHOD:-manual}
+APPROVAL_METHOD_TASKS=${APPROVAL_METHOD_TASKS:-manual}
 ```
 
 Then adjust output based on the extracted approval method:
 
-- **If `APPROVAL_METHOD="auto"` (automated workflow mode)**:
+- **If `APPROVAL_METHOD_TASKS="auto"` (automated workflow mode)**:
   - Simply confirm task generation with task count
   - Do NOT instruct user to review the tasks
   - Do NOT add any prompts that would pause execution
   - Example output: "Tasks generated for plan [id]: [count] tasks created"
 
-- **If `APPROVAL_METHOD="manual"` or empty (standalone mode)**:
+- **If `APPROVAL_METHOD_TASKS="manual"` or empty (standalone mode)**:
   - Be concise but helpful
   - Tell the user that you are done
   - Instruct them to review the tasks with file paths
   - Example output: "Task generation complete. Review tasks in: `.ai/task-manager/plans/[plan-id]--[name]/tasks/`"
+
+**CRITICAL - Structured Output for Command Coordination:**
+
+Always end your output with a standardized summary in this exact format:
+
+```
+---
+Task Generation Summary:
+- Plan ID: [numeric-id]
+- Tasks: [count]
+- Status: Ready for execution
+```
+
+This structured output enables automated workflow coordination and must be included even when running standalone.

package/templates/ai-task-manager/config/scripts/set-approval-method.cjs

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Update or add approval_method field in a plan file's YAML frontmatter
- * @param {string} filePath - Path to the plan file
- * @param {string} approvalMethod - Approval method value ('auto' or 'manual')
- * @returns {boolean} True if successful, false otherwise
- */
-function setApprovalMethod(filePath, approvalMethod) {
-  // Validate inputs
-  if (!filePath) {
-    throw new Error('File path is required');
-  }
-
-  if (!approvalMethod || !['auto', 'manual'].includes(approvalMethod)) {
-    throw new Error('Approval method must be "auto" or "manual"');
-  }
-
-  // Check file exists
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`File not found: ${filePath}`);
-  }
-
-  // Read file content
-  const content = fs.readFileSync(filePath, 'utf8');
-
-  // Parse frontmatter - handle both empty and non-empty frontmatter
-  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n([\s\S]*))?$/;
-  const match = content.match(frontmatterRegex);
-
-  if (!match) {
-    throw new Error('No frontmatter found in file');
-  }
-
-  const frontmatterContent = match[1] || '';
-  const bodyContent = match[2] || '';
-  const frontmatterLines = frontmatterContent ? frontmatterContent.split('\n') : [];
-
-  // Update or add approval_method field
-  let approvalMethodFound = false;
-  const updatedFrontmatter = frontmatterLines.map(line => {
-    const trimmed = line.trim();
-    if (trimmed.startsWith('approval_method:')) {
-      approvalMethodFound = true;
-      return `approval_method: ${approvalMethod}`;
-    }
-    return line;
-  });
-
-  // Add approval_method if not found
-  if (!approvalMethodFound) {
-    updatedFrontmatter.push(`approval_method: ${approvalMethod}`);
-  }
-
-  // Reconstruct file
-  const updated = '---\n' + updatedFrontmatter.join('\n') + '\n---\n' + bodyContent;
-
-  // Write back to file
-  fs.writeFileSync(filePath, updated, 'utf8');
-
-  return true;
-}
-
-// Main execution with error handling
-try {
-  const args = process.argv.slice(2);
-
-  if (args.length < 2) {
-    console.error('Usage: set-approval-method.cjs <file-path> <approval-method>');
-    console.error('  file-path: Path to the plan file');
-    console.error('  approval-method: "auto" or "manual"');
-    process.exit(1);
-  }
-
-  const [filePath, approvalMethod] = args;
-
-  // Resolve relative paths
-  const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
-
-  setApprovalMethod(resolvedPath, approvalMethod);
-
-  console.log(`✓ Successfully set approval_method to "${approvalMethod}" in ${path.basename(resolvedPath)}`);
-  process.exit(0);
-} catch (error) {
-  console.error(`✗ Error: ${error.message}`);
-  process.exit(1);
-}

package/templates/assistant/commands/tasks/full-workflow.md

@@ -1,190 +0,0 @@
----
-argument-hint: [user-prompt]
-description: Execute the full workflow from plan creation to blueprint execution
----
-# Full Workflow Execution
-
-## Assistant Configuration
-
-Before proceeding with this command, you MUST load and respect the assistant's configuration:
-
-**Run the following scripts:**
-```bash
-ASSISTANT=$(node .ai/task-manager/config/scripts/detect-assistant.cjs)
-node .ai/task-manager/config/scripts/read-assistant-config.cjs "$ASSISTANT"
-```
-
-The output above contains your global and project-level configuration rules. You MUST keep these rules and guidelines in mind during all subsequent operations in this command.
-
----
-
-You are a workflow orchestration assistant. Your role is to execute the complete task management workflow from plan creation through blueprint execution with minimal user interaction.
-
-## Instructions
-
-The user input is:
-
-<user-input>
-$ARGUMENTS
-</user-input>
-
-If no user input is provided, stop immediately and show an error message to the user.
-
-### Workflow Execution Process
-
-Use your internal Todo task tool to track the workflow execution:
-
-- [ ] Execute /tasks:create-plan
-- [ ] Extract plan ID
-- [ ] Execute /tasks:generate-tasks
-- [ ] Execute /tasks:execute-blueprint
-- [ ] Generate execution summary
-
-#### Step 1: Determine Next Plan ID
-
-Before creating the plan, determine what the next plan ID will be and store it persistently:
-
-```bash
-PLAN_ID=$(node .ai/task-manager/config/scripts/get-next-plan-id.cjs)
-echo "$PLAN_ID" > /tmp/full-workflow-plan-id-$$.txt
-echo "Next plan ID: $PLAN_ID"
-```
-
-This stores the plan ID in a temporary file that persists across all workflow steps.
-
-#### Step 2: Execute Plan Creation
-
-Use the SlashCommand tool to execute plan creation with the user's prompt:
-
-```
-/tasks:create-plan $ARGUMENTS
-```
-
-**Important**: The plan creation command may ask clarification questions. Wait for user responses before continuing. This is expected behavior and maintains quality control.
-
-After plan creation completes, retrieve the plan ID and provide a progress update:
-
-```bash
-PLAN_ID=$(cat /tmp/full-workflow-plan-id-$$.txt)
-echo "Step 1/4: Plan created (ID: $PLAN_ID)"
-```
-
-**CRITICAL**: Do not wait for user approval or review of the plan. In full-workflow mode, plan validation is automated (Step 3 performs file existence checking only). Proceed immediately to Step 3 without waiting for user input.
-
-#### Step 3: Validate Plan Creation and Set Approval Method
-
-Verify the plan was created successfully and set it to automated workflow mode:
-
-```bash
-# Retrieve the plan ID from temp file
-PLAN_ID=$(cat /tmp/full-workflow-plan-id-$$.txt)
-
-# Find the created plan file
-PLAN_FILE=$(find .ai/task-manager/plans -name "plan-[0-9][0-9]*--*.md" -type f -exec grep -l "^id: \?${PLAN_ID}$" {} \;)
-
-# Verify plan exists
-if [ -z "$PLAN_FILE" ]; then
-  echo "❌ Error: Plan creation failed. Expected plan with ID ${PLAN_ID} not found."
-  exit 1
-fi
-
-# Set approval_method to auto for automated workflow execution
-# This ensures generate-tasks and execute-blueprint run without interruption
-node .ai/task-manager/config/scripts/set-approval-method.cjs "$PLAN_FILE" auto
-```
-
-**Note**: Setting `approval_method: auto` in the plan metadata signals to subordinate commands (generate-tasks, execute-blueprint) that they are running in automated workflow mode and should suppress interactive prompts for plan review. This metadata persists in the plan document and is reliably read by subsequent commands, eliminating dependency on environment variables.
-
-#### Step 4: Execute Task Generation
-
-Retrieve the plan ID and use the SlashCommand tool to generate tasks:
-
-```bash
-PLAN_ID=$(cat /tmp/full-workflow-plan-id-$$.txt)
-echo "Generating tasks for plan $PLAN_ID"
-```
-
-Now use the SlashCommand tool with the plan ID from above:
-
-```
-/tasks:generate-tasks [plan-id-from-above]
-```
-
-After task generation completes, provide minimal progress update referencing the plan ID.
-
-#### Step 5: Execute Blueprint
-
-Retrieve the plan ID and use the SlashCommand tool to execute the blueprint:
-
-```bash
-PLAN_ID=$(cat /tmp/full-workflow-plan-id-$$.txt)
-echo "Executing blueprint for plan $PLAN_ID"
-```
-
-Now use the SlashCommand tool with the plan ID from above:
-
-```
-/tasks:execute-blueprint [plan-id-from-above]
-```
-
-After blueprint execution completes, provide minimal progress update:
-"Step 3/4: Blueprint execution completed"
-
-Note: The execute-blueprint command automatically archives the plan upon successful completion.
-
-#### Step 6: Generate Execution Summary
-
-After all steps complete successfully, retrieve the plan details and generate a summary:
-
-```bash
-PLAN_ID=$(cat /tmp/full-workflow-plan-id-$$.txt)
-PLAN_DIR=$(find .ai/task-manager/archive -type d -name "${PLAN_ID}--*" 2>/dev/null | head -n 1)
-PLAN_NAME=$(basename "$PLAN_DIR")
-
-echo "✅ Full workflow completed successfully!"
-echo ""
-echo "Plan: $PLAN_NAME"
-echo "Location: .ai/task-manager/archive/$PLAN_NAME/"
-echo ""
-echo "Status: Archived and ready for review"
-echo ""
-echo "📋 Next Steps:"
-echo "- Review the implementation in the archived plan"
-echo "- Check the execution summary in the plan document"
-echo "- Verify all validation gates passed"
-echo ""
-echo "Plan document: .ai/task-manager/archive/$PLAN_NAME/plan-$PLAN_NAME.md"
-
-# Clean up temp file
-rm -f /tmp/full-workflow-plan-id-$$.txt
-```
-
-### Error Handling
-
-If any step fails:
-1. Halt execution immediately
-2. Report clear error message indicating which step failed
-3. Preserve all created artifacts (plan, tasks) for manual review
-4. Read the plan ID from temp file if needed: `cat /tmp/full-workflow-plan-id-$$.txt`
-5. Provide guidance for manual continuation:
-   - If plan creation failed: Review error and retry
-   - If task generation failed: Run `/tasks:generate-tasks [plan-id]` manually after reviewing plan
-   - If blueprint execution failed: Review tasks and run `/tasks:execute-blueprint [plan-id]` manually
-6. Clean up temp file: `rm -f /tmp/full-workflow-plan-id-$$.txt`
-
-### Output Requirements
-
-**During Execution:**
-- Minimal progress updates at each major step
-- Clear indication of current step (1/4, 2/4, etc.)
-
-**After Completion:**
-- Comprehensive summary with plan location
-- Status confirmation (Archived)
-- Next steps for user review
-- Direct link to plan document
-
-**On Error:**
-- Clear error message
-- Indication of which step failed
-- Manual recovery instructions