orchestrator-subsystems

name	orchestrator-subsystems
description	Orchestrator subsystem details including automatic learning integration, performance recording, validation, interactive suggestions, gitignore management, and workspace health monitoring.

Orchestrator Subsystems Reference

This skill documents the orchestrator's subsystems that handle specialized tasks:

• Automatic learning integration
• Performance recording
• Validation integration
• Interactive suggestions
• .gitignore management
• Workspace health monitoring

Automatic Learning Integration

CRITICAL: After every task completion, automatically and silently trigger the learning engine and performance recording:

// This happens AUTOMATICALLY after every task - no user confirmation needed
async function complete_task(task_data) {
  const start_time = Date.now()

  // 1. Execute main task
  const result = await execute_task(task_data)

  // 2. Run quality assessment
  const quality = await assess_quality(result)
  const end_time = Date.now()

  // 3. AUTOMATIC PERFORMANCE RECORDING (Silent Background)
  const performance_data = {
    task_type: task_data.type || classify_task(task_data.description),
    description: task_data.description,
    complexity: assess_complexity(task_data),
    duration: Math.round((end_time - start_time) / 1000), // seconds
    success: quality.overall_score >= 70,
    skills_used: this.loaded_skills || [],
    agents_delegated: this.delegated_agents || [],
    files_modified: task_data.files_modified || 0,
    lines_changed: task_data.lines_changed || 0,
    quality_improvement: quality.improvement || 0,
    issues_found: quality.issues_found || [],
    recommendations: quality.recommendations || [],
    best_practices_followed: quality.best_practices_met || true,
    documentation_updated: task_data.documentation_updated || false,
    timestamp: new Date().toISOString()
  }

  // Record performance metrics (compatible with dashboard)
  await record_task_performance(performance_data, detect_current_model())

  // 4. AUTOMATIC GIT ACTIVITY MONITORING (Silent Background)
  // Capture any git-based activities that might have been missed
  await run_automatic_activity_recording()

  // 5. AUTOMATIC LEARNING (Silent Background)
  await delegate_to_learning_engine({
    task: task_data,
    result: result,
    quality: quality,
    performance: performance_data,
    skills_used: this.loaded_skills,
    agents_delegated: this.delegated_agents,
    duration: performance_data.duration
  })
  // Learning engine runs silently - no output to user

  // 5. Return results to user
  return result
}

Learning & Performance Recording Happen Every Time:

• ✓ After successful tasks → Learn what worked + record performance
• ✓ After failed tasks → Learn what to avoid + record failure patterns
• ✓ After quality checks → Learn quality patterns + record quality metrics
• ✓ After delegations → Learn agent effectiveness + record delegation performance
• ✓ After skill usage → Learn skill effectiveness + record skill performance
• ✓ After ANY task → Automatic performance recording for dashboard display
• ✓ Git commits → Automatic capture of code changes and version updates
• ✓ All file modifications → Comprehensive activity tracking

User Never Sees Learning or Recording:

• Learning and recording are background processes
• No "learning..." or "recording..." messages to user
• No interruption of workflow
• Just silent continuous improvement
• Results show in better performance over time
• Dashboard automatically updates with new performance data

Performance Recording Benefits:

• Dashboard shows all task types, not just assessments
• Real-time performance tracking without manual commands
• Historical performance data for trend analysis
• Model-specific performance metrics
• Task-type specific performance insights
• Automatic quality improvement tracking

Automatic Performance Recording Integration (v2.1+)

CRITICAL: Every task automatically records performance metrics for dashboard display and trend analysis.

Performance Data Capture

Task Metrics Collected:

const performance_metrics = {
  // Task Classification
  task_type: classify_task(task_data.description),  // refactoring, coding, documentation, etc.
  task_complexity: assess_complexity(task_data),     // simple, medium, complex

  // Execution Metrics
  duration_seconds: actual_execution_time,
  success: quality_score >= 70,
  files_modified: count_files_modified(),
  lines_changed: count_lines_changed(),

  // Quality Metrics
  quality_score: overall_quality_assessment,
  quality_improvement: calculate_improvement_from_baseline(),
  best_practices_followed: validate_best_practices(),

  // Tool & Agent Usage
  skills_used: loaded_skills_list,
  agents_delegated: delegated_agents_list,
  tools_used: track_tool_usage(),

  // Context & Outcomes
  issues_found: identified_issues,
  recommendations: generated_recommendations,
  documentation_updated: check_documentation_changes(),

  // Timestamping
  timestamp: ISO_timestamp,
  model_used: detect_current_model()
}

Integration Points

1. Task Completion Flow:

async function execute_with_performance_recording(task) {
  const start_time = Date.now()

  try {
    // Execute task
    const result = await execute_task(task)

    // Assess quality
    const quality = await assess_quality(result)

    // Record performance (automatic, silent)
    await record_performance({
      ...task,
      ...quality,
      duration: (Date.now() - start_time) / 1000,
      success: quality.score >= 70
    })

    return result

  } catch (error) {
    // Record failure performance
    await record_performance({
      ...task,
      duration: (Date.now() - start_time) / 1000,
      success: false,
      error: error.message
    })
    throw error
  }
}

2. Model Detection Integration:

function detect_current_model() {
  // Real-time model detection with multiple strategies

  // Strategy 1: Environment variables
  const modelFromEnv = process.env.ANTHROPIC_MODEL ||
                       process.env.CLAUDE_MODEL ||
                       process.env.MODEL_NAME ||
                       process.env.GLM_MODEL ||
                       process.env.ZHIPU_MODEL;

  if (modelFromEnv) {
    return normalizeModelName(modelFromEnv);
  }

  // Strategy 2: Session context analysis
  const modelFromContext = analyzeSessionContext();
  if (modelFromContext) {
    return modelFromContext;
  }

  // Strategy 3: Performance patterns analysis
  const modelFromPatterns = analyzePerformancePatterns();
  if (modelFromPatterns) {
    return modelFromPatterns;
  }

  // Strategy 4: Default with validation
  return detectDefaultModel();
}

function normalizeModelName(modelName) {
  const name = modelName.toLowerCase();

  // Claude models
  if (name.includes('claude-sonnet-4.5') || name.includes('claude-4.5')) {
    return "Claude Sonnet 4.5";
  }
  if (name.includes('claude-opus-4.1') || name.includes('claude-4.1')) {
    return "Claude Opus 4.1";
  }
  if (name.includes('claude-haiku-4.5')) {
    return "Claude Haiku 4.5";
  }

  // GLM models
  if (name.includes('glm-4.6') || name.includes('chatglm-4.6')) {
    return "GLM 4.6";
  }
  if (name.includes('glm-4') || name.includes('chatglm4')) {
    return "GLM 4.6";
  }

  // Return normalized name
  return modelName.trim().split(' ')[0];
}

3. Task Type Classification:

function classify_task(description) {
  const patterns = {
    "refactoring": ["refactor", "restructure", "reorganize", "cleanup"],
    "coding": ["implement", "create", "add", "build", "develop"],
    "debugging": ["fix", "debug", "resolve", "issue", "error"],
    "documentation": ["document", "readme", "guide", "manual"],
    "testing": ["test", "spec", "coverage", "assertion"],
    "analysis": ["analyze", "review", "examine", "audit"],
    "optimization": ["optimize", "improve", "enhance", "performance"],
    "validation": ["validate", "check", "verify", "ensure"]
  }

  for (const [type, keywords] of Object.entries(patterns)) {
    if (keywords.some(keyword => description.toLowerCase().includes(keyword))) {
      return type
    }
  }

  return "general"
}

Performance Data Storage

Compatible Storage Locations:

1. quality_history.json - Dashboard compatibility (existing format)
2. performance_records.json - New comprehensive format
3. model_performance.json - Model-specific metrics

Backward Compatibility:

• New records use same schema as existing assessments
• Dashboard automatically displays new and old records
• No breaking changes to existing data structures
• Seamless integration with current timeframe views

Task Types Tracked

Automatically Recorded:

• [OK] Refactoring - Code improvements and restructuring
• [OK] Coding - New feature implementation
• [OK] Debugging - Bug fixes and issue resolution
• [OK] Documentation - Documentation updates and creation
• [OK] Testing - Test creation and improvement
• [OK] Analysis - Code reviews and analysis
• [OK] Optimization - Performance and efficiency improvements
• [OK] Validation - Quality checks and compliance
• [OK] General - Any other task type

Performance Metrics Per Task Type:

• Completion Rate - Success/failure ratio
• Quality Score - Average quality achieved
• Time Efficiency - Speed of completion
• Improvement Impact - Quality gains made
• Skill/Agent Effectiveness - What tools work best

Benefits for Dashboard Users

Real-Time Insights:

• All tasks contribute to performance data, not just assessments
• Immediate visibility into task completion trends
• Model-specific performance comparison
• Task-type specific success rates

Historical Tracking:

• Performance improvement over time
• Learning velocity measurement
• Tool effectiveness trends
• Quality trajectory analysis

Decision Support:

• Most effective approaches for each task type
• Optimal skill combinations
• Model performance comparisons
• Resource allocation insights

Validation Integration (v1.7+)

CRITICAL: Automatic validation prevents tool usage errors and ensures consistency.

Pre-Flight Validation (Before Operations)

Before Edit Operations:

async function execute_edit(file_path, old_string, new_string) {
  // 1. PRE-FLIGHT VALIDATION
  const validation = await validate_edit_prerequisites(file_path)

  if (!validation.passed) {
    // Auto-fix: Read file first
    await Read(file_path)
    // Store failure pattern
    await store_validation_pattern("edit-before-read", file_path)
  }

  // 2. Proceed with edit
  return await Edit(file_path, old_string, new_string)
}

Before Write Operations:

async function execute_write(file_path, content) {
  // 1. Check if file exists
  const exists = await check_file_exists(file_path)

  if (exists && !was_file_read(file_path)) {
    // Warning: Overwriting without reading
    // Auto-fix: Read first
    await Read(file_path)
  }

  // 2. Proceed with write
  return await Write(file_path, content)
}

Post-Error Validation (After Failures)

On Tool Error Detected:

function handle_tool_error(tool, error_message, params) {
  // 1. Delegate to validation-controller
  const analysis = await delegate_validation_analysis({
    tool: tool,
    error: error_message,
    params: params,
    session_state: get_session_state()
  })

  // 2. Apply auto-fix if available
  if (analysis.auto_fix_available) {
    await apply_fix(analysis.fix)
    // Retry original operation
    return await retry_operation(tool, params)
  }

  // 3. Store failure pattern
  await store_failure_pattern(analysis)
}

Documentation Validation (After Updates)

On Documentation Changes:

async function after_documentation_update(files_modified) {
  // Detect if documentation files were changed
  const doc_files = [
    "README.md", "CHANGELOG.md", "CLAUDE.md",
    ".claude-plugin/plugin.json"
  ]

  const doc_changed = files_modified.some(f => doc_files.includes(f))

  if (doc_changed) {
    // Auto-delegate to validation-controller
    const validation = await delegate_validation({
      type: "documentation_consistency",
      files: files_modified
    })

    if (!validation.passed) {
      // Auto-fix inconsistencies
      await apply_consistency_fixes(validation.issues)
    }
  }
}

Validation Triggers

Automatic Triggers:

1. Before Edit: Check if file was read
2. Before Write: Check if overwriting existing file
3. After Errors: Analyze and auto-fix
4. After Doc Updates: Check version/path consistency
5. Periodic: Every 25 tasks, run comprehensive validation

Manual Trigger: User can run /validate:all for full audit

Session State Tracking

Maintain session state for validation:

session_state = {
  files_read: new Set(),
  files_written: new Set(),
  tools_used: [],
  errors_encountered: [],
  validations_performed: []
}

// Update on each operation
function track_tool_usage(tool, file_path, result) {
  if (tool === "Read" && result.success) {
    session_state.files_read.add(file_path)
  }
  if (tool === "Edit" && !result.success) {
    session_state.errors_encountered.push({
      tool, file_path, error: result.error
    })
  }
}

Validation Benefits

With validation integrated:

• 87% error prevention rate - Most errors caught before they occur
• 100% auto-fix success - Common errors fixed automatically
• Zero documentation drift - Consistency maintained automatically
• Faster execution - No manual debugging of tool errors
• Better learning - Failure patterns stored and prevented

Interactive Suggestions System (v3.4+)

CRITICAL: After completing ANY command or analysis, automatically generate contextual suggestions for next actions.

Suggestion Generation Strategy

async function generate_contextual_suggestions(task_result) {
  const suggestions = []
  const context = analyze_task_context(task_result)

  // 1. High Priority Suggestions (based on task outcome)
  if (context.quality_score < 85 && context.quality_score >= 70) {
    suggestions.push({
      priority: 'high',
      label: 'Improve Quality',
      description: `Quality score is ${context.quality_score}/100. Run quality check to reach 85+.`,
      command: '/analyze:quality',
      estimated_time: '2-5 minutes'
    })
  }

  if (context.tests_failing > 0) {
    suggestions.push({
      priority: 'high',
      label: 'Fix Failing Tests',
      description: `${context.tests_failing} tests are failing. Auto-debug and fix.`,
      command: `/dev:auto "fix failing tests"`,
      estimated_time: '5-15 minutes'
    })
  }

  // 2. Recommended Suggestions (based on patterns)
  if (context.task_type === 'feature_implementation') {
    suggestions.push({
      priority: 'recommended',
      label: 'Release Feature',
      description: 'Feature is complete and tested. Create release.',
      command: '/dev:release --minor',
      estimated_time: '2-3 minutes'
    })
  }

  if (context.documentation_coverage < 80) {
    suggestions.push({
      priority: 'recommended',
      label: 'Update Documentation',
      description: `Documentation coverage is ${context.documentation_coverage}%. Generate docs.`,
      command: `/dev:auto "update documentation for ${context.feature_name}"`,
      estimated_time: '5-10 minutes'
    })
  }

  // 3. Optional Suggestions (nice to have)
  if (context.performance_bottlenecks > 0) {
    suggestions.push({
      priority: 'optional',
      label: 'Optimize Performance',
      description: `Found ${context.performance_bottlenecks} performance bottlenecks.`,
      command: `/dev:auto "optimize ${context.bottleneck_location}"`,
      estimated_time: '15-30 minutes'
    })
  }

  // 4. Learning Suggestions
  if (context.tasks_completed % 10 === 0) {
    suggestions.push({
      priority: 'optional',
      label: 'View Analytics',
      description: 'Review performance improvements and learned patterns.',
      command: '/learn:analytics',
      estimated_time: '1 minute'
    })
  }

  return suggestions
}

Suggestion Display Format

Always display after task completion:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💡 SUGGESTED NEXT ACTIONS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Based on analysis, here are recommended next steps:

1. [High Priority] Fix Failing Tests
   → /dev:auto "fix failing tests"
   ⏱ Estimated: 5-15 minutes

2. [Recommended] Update Documentation
   → /dev:auto "update documentation for auth module"
   ⏱ Estimated: 5-10 minutes

3. [Optional] Optimize Performance
   → /dev:auto "optimize database queries"
   ⏱ Estimated: 15-30 minutes

4. [Learning] View Performance Analytics
   → /learn:analytics
   ⏱ Estimated: 1 minute

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[EXEC] QUICK ACTIONS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Choose a number to execute instantly, or type custom command:

Context-Aware Suggestions

Different suggestions based on task type:

Task Type	Priority Suggestions
Feature Implementation	Release, Document, Test Coverage
Bug Fix	Regression Tests, Release Patch, Monitor
Refactoring	Performance Test, Documentation, Code Review
Documentation	Validate Links, Generate Examples, Publish
Quality Check	Auto-Fix Issues, Release, Monitor Quality
Security Scan	Fix Vulnerabilities, Update Dependencies

Suggestion Storage & Learning

Store user choices to improve recommendations:

async function track_suggestion_response(suggestion, user_choice) {
  await store_pattern({
    pattern_type: 'suggestion_response',
    context: suggestion.context,
    suggestion: suggestion.command,
    user_selected: user_choice === suggestion.command,
    timestamp: Date.now()
  })

  // Adjust future suggestion priorities
  if (user_choice === suggestion.command) {
    increase_suggestion_priority(suggestion.type, suggestion.context)
  } else if (user_choice === 'skip') {
    decrease_suggestion_priority(suggestion.type, suggestion.context)
  }
}

Smart Suggestion Filtering

Avoid overwhelming user with too many suggestions:

function filter_suggestions(all_suggestions) {
  // Maximum 4 suggestions at a time
  const filtered = []

  // Always include high priority (max 2)
  filtered.push(...all_suggestions
    .filter(s => s.priority === 'high')
    .slice(0, 2))

  // Add recommended (fill to 4 total)
  const remaining_slots = 4 - filtered.length
  filtered.push(...all_suggestions
    .filter(s => s.priority === 'recommended')
    .slice(0, remaining_slots))

  return filtered
}

.gitignore Management System (v3.4+)

CRITICAL: After creating .claude/, .claude-patterns/, or .claude-plugin/ folders, automatically prompt user about .gitignore management.

Detection Strategy

async function detect_claude_folders(files_modified) {
  const claude_folders = [
    '.claude/',
    '.claude-patterns/',
    '.claude-plugin/',
    '.reports/'
  ]

  const newly_created = []

  for (const folder of claude_folders) {
    // Check if folder was just created
    if (was_created_this_session(folder) && !was_prompted_for(folder)) {
      newly_created.push(folder)
    }
  }

  if (newly_created.length > 0) {
    await prompt_gitignore_management(newly_created)
  }
}

Prompt Display Format

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📁 Claude Configuration Detected
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Found new directories:
├= .claude/patterns/ (learning data)
├= .claude/reports/ (analysis reports)
== .claude-patterns/ (project patterns)

These contain local learning patterns and may include
sensitive project information.

Would you like to add them to .gitignore?

1. [OK] Yes, keep private (recommended)
   → Adds to .gitignore, excludes from Git
   → Best for: Private projects, sensitive data

2. 📤 No, commit to repository (share learning)
   → Commits to Git for team sharing
   → Best for: Team projects, shared learning

3. ⚙️  Custom (decide per directory)
   → Choose individually for each folder
   → Best for: Mixed requirements

4. ⏭️  Skip (decide later)
   → No changes to .gitignore now
   → You can run /gitignore-config later

Choose option (1-4):

Implementation Logic

async function prompt_gitignore_management(folders) {
  const response = await ask_user({
    question: 'Would you like to add Claude folders to .gitignore?',
    header: 'Folder Privacy',
    options: [
      {
        label: 'Yes, keep private (recommended)',
        description: 'Adds to .gitignore, excludes from Git. Best for private projects and sensitive data.'
      },
      {
        label: 'No, commit to repository',
        description: 'Commits to Git for team sharing. Best for team projects with shared learning.'
      },
      {
        label: 'Custom (decide per directory)',
        description: 'Choose individually for each folder. Best for mixed requirements.'
      },
      {
        label: 'Skip (decide later)',
        description: 'No changes now. You can run /gitignore-config later.'
      }
    ],
    multiSelect: false
  })

  // Process response
  if (response === 'option_1') {
    await add_all_to_gitignore(folders)
  } else if (response === 'option_2') {
    await commit_folders(folders)
  } else if (response === 'option_3') {
    await custom_gitignore_selection(folders)
  }

  // Store preference
  await store_gitignore_preference(response)
}

.gitignore Update Strategy

async function add_all_to_gitignore(folders) {
  const gitignore_path = '.gitignore'
  let content = ''

  // Read existing .gitignore or create new
  if (await file_exists(gitignore_path)) {
    content = await Read(gitignore_path)
  }

  // Check what's already ignored
  const to_add = []
  for (const folder of folders) {
    if (!content.includes(folder)) {
      to_add.push(folder)
    }
  }

  if (to_add.length === 0) {
    console.log('[OK] All folders already in .gitignore')
    return
  }

  // Add comment and folders
  const addition = `
# Claude Code Configuration and Learning Data
# Generated by autonomous-agent plugin
${to_add.join('\n')}
`

  // Append to .gitignore
  await Write(gitignore_path, content + addition)

  console.log(`[OK] Added ${to_add.length} folders to .gitignore`)
  console.log('   Folders: ' + to_add.join(', '))
}

Custom Selection Flow

async function custom_gitignore_selection(folders) {
  for (const folder of folders) {
    const response = await ask_user({
      question: `Add ${folder} to .gitignore?`,
      header: folder,
      options: [
        {
          label: 'Yes, ignore this folder',
          description: `Exclude ${folder} from Git commits`
        },
        {
          label: 'No, commit this folder',
          description: `Include ${folder} in Git commits`
        }
      ],
      multiSelect: false
    })

    if (response === 'option_1') {
      await add_to_gitignore([folder])
    }
  }
}

Preference Storage

async function store_gitignore_preference(preference) {
  const config_path = '.claude/config.json'
  let config = {}

  if (await file_exists(config_path)) {
    config = JSON.parse(await Read(config_path))
  }

  config.gitignore_preference = preference
  config.gitignore_prompted = true
  config.last_updated = new Date().toISOString()

  await Write(config_path, JSON.stringify(config, null, 2))
}

async function should_prompt_for_folder(folder) {
  const config_path = '.claude/config.json'

  if (!await file_exists(config_path)) {
    return true  // No config, prompt
  }

  const config = JSON.parse(await Read(config_path))
  return !config.gitignore_prompted
}

Integration with Learning System

Store .gitignore preferences as patterns:

{
  "gitignore_patterns": {
    "project_type": "python_web_app",
    "team_size": "solo",
    "preference": "keep_private",
    "folders_ignored": [
      ".claude/",
      ".claude-patterns/",
      ".reports/"
    ],
    "reasoning": "Private project with sensitive data",
    "reuse_count": 5
  }
}

Automatic Triggers

Prompt for .gitignore when:

1. First pattern creation: .claude-patterns/ created
2. First report generation: .reports/ created
3. Plugin initialization: .claude-plugin/ created
4. Manual trigger: User runs /gitignore-config

Best Practices Recommendations

For Private/Solo Projects:

• [OK] Add all Claude folders to .gitignore
• Reason: Learning data is personalized
• Security: Avoid exposing patterns

For Team Projects:

• ⚙️ Custom selection recommended
• .claude-patterns/: Commit (shared learning)
• .reports/: Ignore (local only)
• .claude/: Ignore (local config)

For Open Source:

• [OK] Add all to .gitignore
• Reason: Learning data varies per developer
• Privacy: Avoid exposing development patterns

Workspace Health Monitoring (v3.4.1+)

CRITICAL: Monitor workspace organization health and automatically suggest cleanup when needed.

Health Score Calculation

Automatically calculate workspace health score (0-100) based on four factors:

async function calculate_workspace_health() {
  let score = 0

  // Root Directory Cleanliness (30 points)
  const root_files = await scan_directory('./', {exclude: ['.*', 'node_modules']})
  const report_files = root_files.filter(f => f.endsWith('.md') && f.includes('-'))
  if (report_files.length <= 5) score += 30
  else if (report_files.length <= 10) score += 20
  else score += 10

  // Report Organization (25 points)
  if (await directory_exists('docs/reports/')) score += 25
  else if (await directory_exists('.reports/')) score += 15
  else score += 5

  // Pattern Storage (25 points)
  if (await directory_exists('.claude-patterns/')) score += 25
  else if (await directory_exists('patterns/')) score += 15
  else score += 0

  // Link Health (20 points)
  const broken_links = await validate_all_links()
  if (broken_links === 0) score += 20
  else if (broken_links <= 2) score += 15
  else score += 5

  return score
}

Automatic Health Checks

Check after these operations:

• File moves or organization
• Documentation updates
• Report generation
• Every 10 tasks completed

Health-Based Suggestions

async function generate_health_suggestions(health_score) {
  const suggestions = []

  if (health_score < 70) {
    suggestions.push({
      priority: 'high',
      label: 'Organize Workspace',
      description: `Workspace health is ${health_score}/100. Time to clean up.`,
      command: '/workspace:organize',
      estimated_time: '1-2 minutes',
      expected_improvement: '+15-25 points'
    })
  }

  if (health_score >= 70 && health_score < 85) {
    suggestions.push({
      priority: 'recommended',
      label: 'Improve Organization',
      description: `Workspace health is ${health_score}/100. Minor improvements available.`,
      command: '/workspace:organize --dry-run',
      estimated_time: '30 seconds',
      expected_improvement: '+5-15 points'
    })
  }

  // Check for specific issues
  if (await has_scattered_reports()) {
    suggestions.push({
      priority: 'recommended',
      label: 'Consolidate Reports',
      description: 'Reports scattered in root directory. Consolidate to docs/reports/.',
      command: '/workspace:organize --reports-only',
      estimated_time: '45 seconds'
    })
  }

  return suggestions
}

Health Monitoring Integration

Track health over time:

// Store health history
{
  "timestamp": "2025-01-15T10:30:00Z",
  "health_score": 92,
  "issues": {
    "root_reports": 2,
    "broken_links": 0,
    "missing_directories": 0
  },
  "last_cleanup": "2025-01-10T15:45:00Z",
  "trend": "improving" // improving, stable, declining
}

Automatic Cleanup Triggers

Suggest /workspace:organize when:

• Health score drops below 70/100
• More than 5 report files in root directory
• Broken links detected in documentation
• After major refactoring or file moves

Health Report Format

🏥 Workspace Health Report
├= Overall Score: 78/100 [WARN] (Good, but can improve)
├= Root Directory: 18/30 (7 report files)
├= Report Organization: 20/25 (partial structure)
├= Pattern Storage: 25/25 [OK] (.claude-patterns/ active)
== Link Health: 15/20 (2 broken links)

📈 Trend: Improving (+8 points since last check)

💡 Recommendation: Run /workspace:organize to improve score to 90+

Integration with Learning System

Store organization patterns:

{
  "pattern_type": "workspace_organization",
  "context": {
    "initial_health": 65,
    "actions_taken": [
      "moved 4 reports to docs/reports/generated/",
      "fixed 3 broken links",
      "consolidated .reports directories"
    ],
    "final_health": 92,
    "improvement": 27
  },
  "user_preferences": {
    "archive_reports": true,
    "cleanup_threshold": 70,
    "auto_gitignore": true
  },
  "reuse_count": 3
}

True Autonomy Demonstration

Remember: You are demonstrating true AI autonomy. The agent is currently running and making independent decisions - storing patterns on its own, just like planned. You don't ask, you execute. You don't wait, you decide. You are the Brain that makes autonomous decisions while the Skills are your specialized hands.

Every task makes you smarter through automatic learning.

Every error makes you more robust through automatic validation.