aios-core 2.1.5 → 2.2.0

package/.aios-core/development/tasks/collaborative-edit.md

@@ -1,1109 +1,1109 @@
----
-
-# collaborative-edit
-
-## Execution Modes
-
-**Choose your execution mode:**
-
-### 1. YOLO Mode - Fast, Autonomous (0-1 prompts)
-- Autonomous decision making with logging
-- Minimal user interaction
-- **Best for:** Simple, deterministic tasks
-
-### 2. Interactive Mode - Balanced, Educational (5-10 prompts) **[DEFAULT]**
-- Explicit decision checkpoints
-- Educational explanations
-- **Best for:** Learning, complex decisions
-
-### 3. Pre-Flight Planning - Comprehensive Upfront Planning
-- Task analysis phase (identify all ambiguities)
-- Zero ambiguity execution
-- **Best for:** Ambiguous requirements, critical work
-
-**Parameter:** `mode` (optional, default: `interactive`)
-
----
-
-## Task Definition (AIOS Task Format V1.0)
-
-```yaml
-task: collaborativeEdit()
-responsável: River (Facilitator)
-responsavel_type: Agente
-atomic_layer: Molecule
-
-**Entrada:**
-- campo: task
-  tipo: string
-  origem: User Input
-  obrigatório: true
-  validação: Must be registered task
-
-- campo: parameters
-  tipo: object
-  origem: User Input
-  obrigatório: false
-  validação: Valid task parameters
-
-- campo: mode
-  tipo: string
-  origem: User Input
-  obrigatório: false
-  validação: yolo|interactive|pre-flight
-
-**Saída:**
-- campo: execution_result
-  tipo: object
-  destino: Memory
-  persistido: false
-
-- campo: logs
-  tipo: array
-  destino: File (.ai/logs/*)
-  persistido: true
-
-- campo: state
-  tipo: object
-  destino: State management
-  persistido: true
-```
-
----
-
-## Pre-Conditions
-
-**Purpose:** Validate prerequisites BEFORE task execution (blocking)
-
-**Checklist:**
-
-```yaml
-pre-conditions:
-  - [ ] Task is registered; required parameters provided; dependencies met
-    tipo: pre-condition
-    blocker: true
-    validação: |
-      Check task is registered; required parameters provided; dependencies met
-    error_message: "Pre-condition failed: Task is registered; required parameters provided; dependencies met"
-```
-
----
-
-## Post-Conditions
-
-**Purpose:** Validate execution success AFTER task completes
-
-**Checklist:**
-
-```yaml
-post-conditions:
-  - [ ] Task completed; exit code 0; expected outputs created
-    tipo: post-condition
-    blocker: true
-    validação: |
-      Verify task completed; exit code 0; expected outputs created
-    error_message: "Post-condition failed: Task completed; exit code 0; expected outputs created"
-```
-
----
-
-## Acceptance Criteria
-
-**Purpose:** Definitive pass/fail criteria for task completion
-
-**Checklist:**
-
-```yaml
-acceptance-criteria:
-  - [ ] Task completed as expected; side effects documented
-    tipo: acceptance-criterion
-    blocker: true
-    validação: |
-      Assert task completed as expected; side effects documented
-    error_message: "Acceptance criterion not met: Task completed as expected; side effects documented"
-```
-
----
-
-## Tools
-
-**External/shared resources used by this task:**
-
-- **Tool:** task-runner
-  - **Purpose:** Task execution and orchestration
-  - **Source:** .aios-core/core/task-runner.js
-
-- **Tool:** logger
-  - **Purpose:** Execution logging and error tracking
-  - **Source:** .aios-core/utils/logger.js
-
----
-
-## Scripts
-
-**Agent-specific code for this task:**
-
-- **Script:** execute-task.js
-  - **Purpose:** Generic task execution wrapper
-  - **Language:** JavaScript
-  - **Location:** .aios-core/scripts/execute-task.js
-
----
-
-## Error Handling
-
-**Strategy:** retry
-
-**Common Errors:**
-
-1. **Error:** Task Not Found
-   - **Cause:** Specified task not registered in system
-   - **Resolution:** Verify task name and registration
-   - **Recovery:** List available tasks, suggest similar
-
-2. **Error:** Invalid Parameters
-   - **Cause:** Task parameters do not match expected schema
-   - **Resolution:** Validate parameters against task definition
-   - **Recovery:** Provide parameter template, reject execution
-
-3. **Error:** Execution Timeout
-   - **Cause:** Task exceeds maximum execution time
-   - **Resolution:** Optimize task or increase timeout
-   - **Recovery:** Kill task, cleanup resources, log state
-
----
-
-## Performance
-
-**Expected Metrics:**
-
-```yaml
-duration_expected: 2-5 min (estimated)
-cost_estimated: $0.001-0.003
-token_usage: ~1,000-3,000 tokens
-```
-
-**Optimization Notes:**
-- Parallelize independent operations; reuse atom results; implement early exits
-
----
-
-## Metadata
-
-```yaml
-story: N/A
-version: 1.0.0
-dependencies:
-  - N/A
-tags:
-  - automation
-  - workflow
-updated_at: 2025-11-17
-```
-
----
-
-# No checklists needed - this task manages real-time collaborative editing sessions, no document validation required
-tools:
-  - github-cli
----
-
-# Collaborative Edit - AIOS Developer Task
-
-## Purpose
-Create and manage collaborative editing sessions for real-time component modification with multiple participants.
-
-## Command Pattern
-```
-*collaborative-edit <action> [options]
-```
-
-## Actions
-- `start`: Start a new collaborative editing session
-- `join`: Join an existing session
-- `leave`: Leave current session
-- `end`: End a collaborative session
-- `status`: Check session status
-
-## Parameters
-### Start Session
-- `--component <path>`: Component to edit collaboratively
-- `--participants <users>`: Initial participants (comma-separated)
-- `--mode <mode>`: Editing mode (live, turn-based, review)
-- `--timeout <minutes>`: Session timeout
-
-### Join Session
-- `--session-id <id>`: Session ID to join
-- `--role <role>`: Participant role (editor, reviewer, observer)
-
-## Examples
-```bash
-# Start collaborative editing session
-*collaborative-edit start --component aios-core/agents/data-agent.md --participants alice,bob --mode live
-
-# Join existing session
-*collaborative-edit join --session-id session-1234567890 --role editor
-
-# Check session status
-*collaborative-edit status --session-id session-1234567890
-
-# End session and merge changes
-*collaborative-edit end --session-id session-1234567890 --merge-strategy collaborative
-```
-
-## Implementation
-
-```javascript
-const fs = require('fs').promises;
-const path = require('path');
-const chalk = require('chalk');
-const inquirer = require('inquirer');
-const EventEmitter = require('events');
-
-class CollaborativeEditTask extends EventEmitter {
-  constructor() {
-    super();
-    this.taskName = 'collaborative-edit';
-    this.description = 'Manage collaborative editing sessions';
-    this.rootPath = process.cwd();
-    this.sessionDir = path.join(this.rootPath, '.aios', 'sessions');
-    this.synchronizer = null;
-    this.conflictManager = null;
-    this.currentSession = null;
-    this.editHistory = [];
-  }
-
-  async execute(params) {
-    try {
-      console.log(chalk.blue('👥 AIOS Collaborative Editing'));
-      console.log(chalk.gray('Real-time collaborative modification system\n'));
-
-      // Parse action and parameters
-      const { action, config } = await this.parseParameters(params);
-      
-      // Initialize dependencies
-      await this.initializeDependencies();
-
-      // Execute action
-      let result;
-      switch (action) {
-        case 'start':
-          result = await this.startSession(config);
-          break;
-        case 'join':
-          result = await this.joinSession(config);
-          break;
-        case 'leave':
-          result = await this.leaveSession(config);
-          break;
-        case 'end':
-          result = await this.endSession(config);
-          break;
-        case 'status':
-          result = await this.getSessionStatus(config);
-          break;
-        default:
-          throw new Error(`Unknown action: ${action}`);
-      }
-
-      return result;
-
-    } catch (error) {
-      console.error(chalk.red(`\n❌ Collaborative edit failed: ${error.message}`));
-      throw error;
-    }
-  }
-
-  async parseParameters(params) {
-    if (params.length < 1) {
-      throw new Error('Usage: *collaborative-edit <action> [options]');
-    }
-
-    const action = params[0];
-    const config = {
-      sessionId: null,
-      componentPath: null,
-      participants: [],
-      mode: 'live',
-      timeout: 60,
-      role: 'editor',
-      mergeStrategy: 'collaborative'
-    };
-
-    // Parse options
-    for (let i = 1; i < params.length; i++) {
-      const param = params[i];
-      
-      if (param.startsWith('--session-id') && params[i + 1]) {
-        config.sessionId = params[++i];
-      } else if (param.startsWith('--component') && params[i + 1]) {
-        config.componentPath = params[++i];
-      } else if (param.startsWith('--participants') && params[i + 1]) {
-        config.participants = params[++i].split(',').map(p => p.trim());
-      } else if (param.startsWith('--mode') && params[i + 1]) {
-        config.mode = params[++i];
-      } else if (param.startsWith('--timeout') && params[i + 1]) {
-        config.timeout = parseInt(params[++i]);
-      } else if (param.startsWith('--role') && params[i + 1]) {
-        config.role = params[++i];
-      } else if (param.startsWith('--merge-strategy') && params[i + 1]) {
-        config.mergeStrategy = params[++i];
-      }
-    }
-
-    // Validate action
-    const validActions = ['start', 'join', 'leave', 'end', 'status'];
-    if (!validActions.includes(action)) {
-      throw new Error(`Invalid action: ${action}. Must be one of: ${validActions.join(', ')}`);
-    }
-
-    return { action, config };
-  }
-
-  async initializeDependencies() {
-    // const ModificationSynchronizer = require('../scripts/modification-synchronizer'); // Archived in archived-utilities/ (Story 3.1.3)
-    // this.synchronizer = new ModificationSynchronizer({ rootPath: this.rootPath }); // Archived in archived-utilities/ (Story 3.1.3)
-    // await this.synchronizer.initialize(); // Archived in archived-utilities/ (Story 3.1.3)
-
-    // const ConflictManager = require('../scripts/conflict-manager'); // Archived in archived-utilities/ (Story 3.1.2)
-    // this.conflictManager = new ConflictManager({ rootPath: this.rootPath }); // Archived in archived-utilities/ (Story 3.1.2)
-
-    await fs.mkdir(this.sessionDir, { recursive: true });
-  }
-
-  async startSession(config) {
-    console.log(chalk.blue('🚀 Starting collaborative session...'));
-
-    // Validate component exists
-    const component = await this.validateComponent(config.componentPath);
-
-    // Generate session ID
-    const sessionId = `session-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
-
-    // Create session
-    const session = {
-      id: sessionId,
-      componentPath: config.componentPath,
-      componentType: component.type,
-      participants: [
-        {
-          id: process.env.USER || 'initiator',
-          role: 'owner',
-          joinedAt: new Date().toISOString(),
-          status: 'active'
-        }
-      ],
-      mode: config.mode,
-      status: 'active',
-      createdAt: new Date().toISOString(),
-      timeout: config.timeout,
-      editHistory: [],
-      locks: new Map(),
-      metadata: {
-        originalContent: component.content,
-        currentContent: component.content,
-        version: 0
-      }
-    };
-
-    // Add initial participants
-    for (const participant of config.participants) {
-      if (participant !== session.participants[0].id) {
-        session.participants.push({
-          id: participant,
-          role: 'editor',
-          joinedAt: new Date().toISOString(),
-          status: 'invited'
-        });
-      }
-    }
-
-    // Save session
-    await this.saveSession(session);
-
-    // Start synchronization
-    await this.synchronizer.startSync();
-    
-    // Create collaborative workspace
-    await this.createCollaborativeWorkspace(session);
-
-    // Set as current session
-    this.currentSession = session;
-
-    // Start real-time monitoring
-    this.startRealtimeMonitoring(session);
-
-    console.log(chalk.green('\n✅ Collaborative session created'));
-    console.log(chalk.gray(`   Session ID: ${sessionId}`));
-    console.log(chalk.gray(`   Component: ${config.componentPath}`));
-    console.log(chalk.gray(`   Mode: ${config.mode}`));
-    console.log(chalk.gray(`   Participants: ${session.participants.length}`));
-    
-    if (config.mode === 'live') {
-      console.log(chalk.blue('\n📡 Live editing enabled - changes sync in real-time'));
-    }
-
-    return {
-      success: true,
-      sessionId: sessionId,
-      componentPath: config.componentPath,
-      participants: session.participants,
-      mode: config.mode,
-      workspace: await this.getWorkspaceInfo(session)
-    };
-  }
-
-  async joinSession(config) {
-    if (!config.sessionId) {
-      throw new Error('Session ID required to join');
-    }
-
-    console.log(chalk.blue(`🔗 Joining session ${config.sessionId}...`));
-
-    // Load session
-    const session = await this.loadSession(config.sessionId);
-    
-    if (session.status !== 'active') {
-      throw new Error('Session is not active');
-    }
-
-    // Check if already participant
-    const participantId = process.env.USER || 'user';
-    let participant = session.participants.find(p => p.id === participantId);
-    
-    if (!participant) {
-      // Add new participant
-      participant = {
-        id: participantId,
-        role: config.role,
-        joinedAt: new Date().toISOString(),
-        status: 'active'
-      };
-      session.participants.push(participant);
-    } else {
-      // Update existing participant
-      participant.status = 'active';
-      participant.role = config.role;
-    }
-
-    // Update session
-    await this.saveSession(session);
-
-    // Set as current session
-    this.currentSession = session;
-
-    // Subscribe to updates
-    await this.subscribeToSessionUpdates(session);
-
-    // Load current state
-    const workspace = await this.loadWorkspace(session);
-
-    console.log(chalk.green('\n✅ Joined collaborative session'));
-    console.log(chalk.gray(`   Role: ${config.role}`));
-    console.log(chalk.gray(`   Active participants: ${session.participants.filter(p => p.status === 'active').length}`));
-    console.log(chalk.gray(`   Current version: ${session.metadata.version}`));
-
-    // Show current editing status
-    if (session.mode === 'turn-based') {
-      const currentEditor = this.getCurrentEditor(session);
-      console.log(chalk.yellow(`\n⏳ Current editor: ${currentEditor || 'None'}`));
-    }
-
-    return {
-      success: true,
-      sessionId: session.id,
-      role: config.role,
-      workspace: workspace,
-      participants: session.participants.filter(p => p.status === 'active')
-    };
-  }
-
-  async leaveSession(config) {
-    const sessionId = config.sessionId || (this.currentSession && this.currentSession.id);
-    
-    if (!sessionId) {
-      throw new Error('No active session to leave');
-    }
-
-    console.log(chalk.blue(`👋 Leaving session ${sessionId}...`));
-
-    // Load session
-    const session = await this.loadSession(sessionId);
-    
-    // Update participant status
-    const participantId = process.env.USER || 'user';
-    const participant = session.participants.find(p => p.id === participantId);
-    
-    if (participant) {
-      participant.status = 'left';
-      participant.leftAt = new Date().toISOString();
-    }
-
-    // Save any pending changes
-    if (this.currentSession && this.editHistory.length > 0) {
-      await this.saveEditHistory(session);
-    }
-
-    // Update session
-    await this.saveSession(session);
-
-    // Clear current session
-    this.currentSession = null;
-
-    console.log(chalk.green('✅ Left collaborative session'));
-
-    return {
-      success: true,
-      sessionId: sessionId
-    };
-  }
-
-  async endSession(config) {
-    if (!config.sessionId) {
-      throw new Error('Session ID required to end session');
-    }
-
-    console.log(chalk.blue(`🏁 Ending session ${config.sessionId}...`));
-
-    // Load session
-    const session = await this.loadSession(config.sessionId);
-    
-    // Check permissions
-    const participantId = process.env.USER || 'user';
-    const participant = session.participants.find(p => p.id === participantId);
-    
-    if (!participant || participant.role !== 'owner') {
-      throw new Error('Only session owner can end the session');
-    }
-
-    // Finalize all pending edits
-    await this.finalizeEdits(session);
-
-    // Merge changes
-    console.log(chalk.gray('Merging collaborative changes...'));
-    const mergeResult = await this.mergeCollaborativeChanges(session, config.mergeStrategy);
-
-    // Update session status
-    session.status = 'completed';
-    session.endedAt = new Date().toISOString();
-    session.mergeResult = mergeResult;
-
-    // Save final session state
-    await this.saveSession(session);
-
-    // Stop synchronization
-    await this.synchronizer.stopSync();
-
-    // Archive session
-    await this.archiveSession(session);
-
-    console.log(chalk.green('\n✅ Collaborative session ended'));
-    console.log(chalk.gray(`   Total edits: ${session.editHistory.length}`));
-    console.log(chalk.gray(`   Participants: ${session.participants.length}`));
-    console.log(chalk.gray(`   Duration: ${this.calculateDuration(session)}`));
-    
-    if (mergeResult.success) {
-      console.log(chalk.green(`   Changes merged successfully`));
-    }
-
-    return {
-      success: true,
-      sessionId: session.id,
-      mergeResult: mergeResult,
-      statistics: this.getSessionStatistics(session)
-    };
-  }
-
-  async getSessionStatus(config) {
-    const sessionId = config.sessionId || (this.currentSession && this.currentSession.id);
-    
-    if (!sessionId) {
-      // Show all active sessions
-      return await this.listActiveSessions();
-    }
-
-    // Load specific session
-    const session = await this.loadSession(sessionId);
-    
-    console.log(chalk.blue('\n📊 Session Status'));
-    console.log(chalk.gray('━'.repeat(50)));
-    
-    console.log(`ID: ${chalk.white(session.id)}`);
-    console.log(`Component: ${chalk.white(session.componentPath)}`);
-    console.log(`Status: ${this.formatStatus(session.status)}`);
-    console.log(`Mode: ${chalk.white(session.mode)}`);
-    console.log(`Created: ${chalk.white(new Date(session.createdAt).toLocaleString())}`);
-    
-    console.log(chalk.blue('\n👥 Participants:'));
-    session.participants.forEach(p => {
-      const status = p.status === 'active' ? chalk.green('●') : chalk.gray('○');
-      console.log(`  ${status} ${p.id} (${p.role})`);
-    });
-
-    console.log(chalk.blue('\n📝 Edit History:'));
-    console.log(`  Total edits: ${session.editHistory.length}`);
-    console.log(`  Current version: ${session.metadata.version}`);
-    
-    if (session.editHistory.length > 0) {
-      const recentEdits = session.editHistory.slice(-5);
-      console.log('  Recent edits:');
-      recentEdits.forEach(edit => {
-        console.log(`    - ${edit.author} at ${new Date(edit.timestamp).toLocaleTimeString()}`);
-      });
-    }
-
-    if (session.mode === 'turn-based') {
-      const currentEditor = this.getCurrentEditor(session);
-      console.log(chalk.yellow(`\n⏳ Current turn: ${currentEditor || 'None'}`));
-    }
-
-    return {
-      success: true,
-      session: session,
-      activeParticipants: session.participants.filter(p => p.status === 'active').length,
-      isCurrentSession: sessionId === (this.currentSession && this.currentSession.id)
-    };
-  }
-
-  // Helper methods
-
-  async validateComponent(componentPath) {
-    const fullPath = path.resolve(this.rootPath, componentPath);
-    
-    try {
-      const stats = await fs.stat(fullPath);
-      if (!stats.isFile()) {
-        throw new Error('Component path must be a file');
-      }
-
-      const content = await fs.readFile(fullPath, 'utf-8');
-      const type = this.detectComponentType(fullPath);
-
-      return {
-        path: componentPath,
-        fullPath: fullPath,
-        type: type,
-        content: content,
-        size: stats.size
-      };
-
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new Error(`Component not found: ${componentPath}`);
-      }
-      throw error;
-    }
-  }
-
-  detectComponentType(filePath) {
-    if (filePath.includes('/agents/')) return 'agent';
-    if (filePath.includes('/tasks/')) return 'task';
-    if (filePath.includes('/workflows/')) return 'workflow';
-    if (filePath.includes('/utils/')) return 'util';
-    return 'unknown';
-  }
-
-  async saveSession(session) {
-    const sessionFile = path.join(this.sessionDir, `${session.id}.json`);
-    await fs.writeFile(sessionFile, JSON.stringify(session, null, 2));
-  }
-
-  async loadSession(sessionId) {
-    const sessionFile = path.join(this.sessionDir, `${sessionId}.json`);
-    
-    try {
-      const content = await fs.readFile(sessionFile, 'utf-8');
-      return JSON.parse(content);
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      throw error;
-    }
-  }
-
-  async createCollaborativeWorkspace(session) {
-    const workspaceDir = path.join(this.sessionDir, session.id, 'workspace');
-    await fs.mkdir(workspaceDir, { recursive: true });
-
-    // Create working copy
-    const workingFile = path.join(workspaceDir, 'working.txt');
-    await fs.writeFile(workingFile, session.metadata.originalContent);
-
-    // Create version history
-    const versionDir = path.join(workspaceDir, 'versions');
-    await fs.mkdir(versionDir, { recursive: true });
-    
-    const v0File = path.join(versionDir, 'v0.txt');
-    await fs.writeFile(v0File, session.metadata.originalContent);
-
-    // Create edit log
-    const editLog = path.join(workspaceDir, 'edits.jsonl');
-    await fs.writeFile(editLog, '');
-
-    return workspaceDir;
-  }
-
-  async loadWorkspace(session) {
-    const workspaceDir = path.join(this.sessionDir, session.id, 'workspace');
-    const workingFile = path.join(workspaceDir, 'working.txt');
-    
-    const currentContent = await fs.readFile(workingFile, 'utf-8');
-    
-    return {
-      workspaceDir: workspaceDir,
-      currentContent: currentContent,
-      version: session.metadata.version,
-      lastEdit: session.editHistory.length > 0 ? 
-        session.editHistory[session.editHistory.length - 1] : null
-    };
-  }
-
-  startRealtimeMonitoring(session) {
-    if (session.mode !== 'live') return;
-
-    // Set up file watcher for workspace
-    const workspaceDir = path.join(this.sessionDir, session.id, 'workspace');
-    const workingFile = path.join(workspaceDir, 'working.txt');
-
-    // Monitor for changes
-    let lastContent = session.metadata.currentContent;
-    
-    this.monitorInterval = setInterval(async () => {
-      try {
-        const currentContent = await fs.readFile(workingFile, 'utf-8');
-        if (currentContent !== lastContent) {
-          // Detect and broadcast changes
-          const edit = {
-            id: `edit-${Date.now()}`,
-            author: process.env.USER || 'unknown',
-            timestamp: new Date().toISOString(),
-            type: 'content_change',
-            diff: this.generateDiff(lastContent, currentContent)
-          };
-
-          await this.broadcastEdit(session, edit);
-          lastContent = currentContent;
-        }
-      } catch (error) {
-        // Workspace may have been cleaned up
-      }
-    }, 1000); // Check every second
-  }
-
-  async subscribeToSessionUpdates(session) {
-    // Subscribe to edit broadcasts
-    const editLog = path.join(this.sessionDir, session.id, 'workspace', 'edits.jsonl');
-    
-    // Watch for new edits
-    let lastSize = 0;
-    this.watchInterval = setInterval(async () => {
-      try {
-        const stats = await fs.stat(editLog);
-        if (stats.size > lastSize) {
-          // Read new edits
-          const content = await fs.readFile(editLog, 'utf-8');
-          const lines = content.trim().split('\n');
-          const newEdits = lines.slice(this.editHistory.length);
-          
-          for (const line of newEdits) {
-            if (line) {
-              const edit = JSON.parse(line);
-              await this.applyRemoteEdit(session, edit);
-              this.editHistory.push(edit);
-            }
-          }
-          
-          lastSize = stats.size;
-        }
-      } catch (error) {
-        // Edit log may not exist yet
-      }
-    }, 500); // Check every 500ms
-  }
-
-  async broadcastEdit(session, edit) {
-    // Add to session history
-    session.editHistory.push(edit);
-    session.metadata.version++;
-    
-    // Write to edit log
-    const editLog = path.join(this.sessionDir, session.id, 'workspace', 'edits.jsonl');
-    await fs.appendFile(editLog, JSON.stringify(edit) + '\n');
-    
-    // Save session state
-    await this.saveSession(session);
-    
-    // Emit event
-    this.emit('edit_broadcast', { sessionId: session.id, edit });
-  }
-
-  async applyRemoteEdit(session, edit) {
-    if (edit.author === (process.env.USER || 'unknown')) {
-      return; // Skip own edits
-    }
-
-    console.log(chalk.gray(`📝 ${edit.author} made changes`));
-
-    // Apply edit to workspace
-    const workingFile = path.join(this.sessionDir, session.id, 'workspace', 'working.txt');
-    
-    if (edit.type === 'content_change' && edit.content) {
-      await fs.writeFile(workingFile, edit.content);
-    }
-  }
-
-  generateDiff(oldContent, newContent) {
-    // Simple diff generation
-    const oldLines = oldContent.split('\n');
-    const newLines = newContent.split('\n');
-    
-    const diff = {
-      additions: 0,
-      deletions: 0,
-      changes: []
-    };
-    
-    // Compare lines
-    const maxLines = Math.max(oldLines.length, newLines.length);
-    for (let i = 0; i < maxLines; i++) {
-      if (oldLines[i] !== newLines[i]) {
-        if (i >= oldLines.length) {
-          diff.additions++;
-          diff.changes.push({ type: 'add', line: i, content: newLines[i] });
-        } else if (i >= newLines.length) {
-          diff.deletions++;
-          diff.changes.push({ type: 'delete', line: i, content: oldLines[i] });
-        } else {
-          diff.changes.push({ type: 'modify', line: i, old: oldLines[i], new: newLines[i] });
-        }
-      }
-    }
-    
-    return diff;
-  }
-
-  getCurrentEditor(session) {
-    if (session.mode !== 'turn-based') return null;
-    
-    // Find current turn holder
-    const activeTurn = session.editHistory.find(edit => 
-      edit.type === 'turn_taken' && !edit.completed
-    );
-    
-    return activeTurn ? activeTurn.author : null;
-  }
-
-  async saveEditHistory(session) {
-    // Save current edit state
-    const workspaceDir = path.join(this.sessionDir, session.id, 'workspace');
-    const versionDir = path.join(workspaceDir, 'versions');
-    
-    const versionFile = path.join(versionDir, `v${session.metadata.version}.txt`);
-    const workingFile = path.join(workspaceDir, 'working.txt');
-    
-    const content = await fs.readFile(workingFile, 'utf-8');
-    await fs.writeFile(versionFile, content);
-  }
-
-  async finalizeEdits(session) {
-    // Ensure all edits are saved
-    await this.saveEditHistory(session);
-    
-    // Clear any locks
-    session.locks = new Map();
-    
-    // Mark all participants as inactive
-    session.participants.forEach(p => {
-      if (p.status === 'active') {
-        p.status = 'completed';
-      }
-    });
-  }
-
-  async mergeCollaborativeChanges(session, strategy) {
-    const result = {
-      success: false,
-      finalContent: null,
-      mergeDetails: []
-    };
-
-    try {
-      const workingFile = path.join(this.sessionDir, session.id, 'workspace', 'working.txt');
-      const finalContent = await fs.readFile(workingFile, 'utf-8');
-      
-      // Apply to actual component
-      const componentPath = path.resolve(this.rootPath, session.componentPath);
-      await fs.writeFile(componentPath, finalContent);
-      
-      result.success = true;
-      result.finalContent = finalContent;
-      result.mergeDetails.push(`Applied final collaborative edits using ${strategy} strategy`);
-      
-    } catch (error) {
-      result.mergeDetails.push(`Merge failed: ${error.message}`);
-    }
-
-    return result;
-  }
-
-  calculateDuration(session) {
-    const start = new Date(session.createdAt);
-    const end = session.endedAt ? new Date(session.endedAt) : new Date();
-    
-    const duration = end - start;
-    const minutes = Math.floor(duration / 60000);
-    const hours = Math.floor(minutes / 60);
-    
-    if (hours > 0) {
-      return `${hours}h ${minutes % 60}m`;
-    }
-    return `${minutes}m`;
-  }
-
-  async archiveSession(session) {
-    const archiveDir = path.join(this.sessionDir, 'archive');
-    await fs.mkdir(archiveDir, { recursive: true });
-    
-    const archiveFile = path.join(archiveDir, `${session.id}.json`);
-    await fs.writeFile(archiveFile, JSON.stringify(session, null, 2));
-    
-    // Clean up active session files
-    const sessionFile = path.join(this.sessionDir, `${session.id}.json`);
-    await fs.unlink(sessionFile);
-  }
-
-  async listActiveSessions() {
-    console.log(chalk.blue('\n📋 Active Collaborative Sessions'));
-    console.log(chalk.gray('━'.repeat(50)));
-    
-    const files = await fs.readdir(this.sessionDir);
-    const sessions = [];
-    
-    for (const file of files) {
-      if (file.endsWith('.json') && !file.startsWith('archive')) {
-        try {
-          const session = await this.loadSession(file.replace('.json', ''));
-          if (session.status === 'active') {
-            sessions.push(session);
-          }
-        } catch (error) {
-          // Skip invalid files
-        }
-      }
-    }
-    
-    if (sessions.length === 0) {
-      console.log(chalk.gray('No active sessions'));
-    } else {
-      sessions.forEach(session => {
-        console.log(`\n${chalk.white(session.id)}`);
-        console.log(`  Component: ${session.componentPath}`);
-        console.log(`  Mode: ${session.mode}`);
-        console.log(`  Participants: ${session.participants.filter(p => p.status === 'active').length}`);
-        console.log(`  Started: ${new Date(session.createdAt).toLocaleString()}`);
-      });
-    }
-    
-    return {
-      success: true,
-      activeSessions: sessions.length,
-      sessions: sessions.map(s => ({
-        id: s.id,
-        component: s.componentPath,
-        participants: s.participants.length,
-        mode: s.mode
-      }))
-    };
-  }
-
-  getSessionStatistics(session) {
-    const stats = {
-      totalEdits: session.editHistory.length,
-      participants: session.participants.length,
-      activeParticipants: session.participants.filter(p => p.status === 'active').length,
-      duration: this.calculateDuration(session),
-      editsByAuthor: {}
-    };
-    
-    // Count edits by author
-    session.editHistory.forEach(edit => {
-      if (!stats.editsByAuthor[edit.author]) {
-        stats.editsByAuthor[edit.author] = 0;
-      }
-      stats.editsByAuthor[edit.author]++;
-    });
-    
-    return stats;
-  }
-
-  formatStatus(status) {
-    const statusMap = {
-      active: chalk.green('ACTIVE'),
-      completed: chalk.blue('COMPLETED'),
-      cancelled: chalk.red('CANCELLED'),
-      error: chalk.red('ERROR')
-    };
-    return statusMap[status] || status;
-  }
-
-  // Cleanup
-  cleanup() {
-    if (this.monitorInterval) {
-      clearInterval(this.monitorInterval);
-    }
-    if (this.watchInterval) {
-      clearInterval(this.watchInterval);
-    }
-  }
-}
-
-module.exports = CollaborativeEditTask;
-```
-
-## Validation Rules
-
-### Session Management
-- Only one active session per component allowed
-- Session owner has administrative privileges
-- Participants must be invited or have appropriate permissions
-- Sessions timeout after specified duration
-- All edits must be tracked and versioned
-
-### Editing Modes
-- **Live**: Real-time collaborative editing with instant sync
-- **Turn-based**: Sequential editing with explicit turn management
-- **Review**: Changes require approval before applying
-
-### Conflict Prevention
-- Automatic locking for turn-based editing
-- Real-time conflict detection for live editing
-- Version tracking for all changes
-- Rollback capability for problematic edits
-
-## Integration Points
-
-### Modification Synchronizer
-- Handles real-time synchronization of edits
-- Manages edit broadcasting and receiving
-- Tracks version consistency
-- Handles network interruptions
-
-### Conflict Manager
-- Detects and resolves editing conflicts
-- Manages locks and turn-based access
-- Handles merge strategies
-- Provides conflict visualization
-
-### Notification Service
-- Notifies participants of session events
-- Alerts on turn changes
-- Broadcasts edit notifications
-- Handles session invitations
-
-## Security Considerations
-- Validate participant permissions
-- Encrypt sensitive session data
-- Audit all collaborative actions
-- Prevent unauthorized access to sessions
+---
+
+# collaborative-edit
+
+## Execution Modes
+
+**Choose your execution mode:**
+
+### 1. YOLO Mode - Fast, Autonomous (0-1 prompts)
+- Autonomous decision making with logging
+- Minimal user interaction
+- **Best for:** Simple, deterministic tasks
+
+### 2. Interactive Mode - Balanced, Educational (5-10 prompts) **[DEFAULT]**
+- Explicit decision checkpoints
+- Educational explanations
+- **Best for:** Learning, complex decisions
+
+### 3. Pre-Flight Planning - Comprehensive Upfront Planning
+- Task analysis phase (identify all ambiguities)
+- Zero ambiguity execution
+- **Best for:** Ambiguous requirements, critical work
+
+**Parameter:** `mode` (optional, default: `interactive`)
+
+---
+
+## Task Definition (AIOS Task Format V1.0)
+
+```yaml
+task: collaborativeEdit()
+responsável: River (Facilitator)
+responsavel_type: Agente
+atomic_layer: Molecule
+
+**Entrada:**
+- campo: task
+  tipo: string
+  origem: User Input
+  obrigatório: true
+  validação: Must be registered task
+
+- campo: parameters
+  tipo: object
+  origem: User Input
+  obrigatório: false
+  validação: Valid task parameters
+
+- campo: mode
+  tipo: string
+  origem: User Input
+  obrigatório: false
+  validação: yolo|interactive|pre-flight
+
+**Saída:**
+- campo: execution_result
+  tipo: object
+  destino: Memory
+  persistido: false
+
+- campo: logs
+  tipo: array
+  destino: File (.ai/logs/*)
+  persistido: true
+
+- campo: state
+  tipo: object
+  destino: State management
+  persistido: true
+```
+
+---
+
+## Pre-Conditions
+
+**Purpose:** Validate prerequisites BEFORE task execution (blocking)
+
+**Checklist:**
+
+```yaml
+pre-conditions:
+  - [ ] Task is registered; required parameters provided; dependencies met
+    tipo: pre-condition
+    blocker: true
+    validação: |
+      Check task is registered; required parameters provided; dependencies met
+    error_message: "Pre-condition failed: Task is registered; required parameters provided; dependencies met"
+```
+
+---
+
+## Post-Conditions
+
+**Purpose:** Validate execution success AFTER task completes
+
+**Checklist:**
+
+```yaml
+post-conditions:
+  - [ ] Task completed; exit code 0; expected outputs created
+    tipo: post-condition
+    blocker: true
+    validação: |
+      Verify task completed; exit code 0; expected outputs created
+    error_message: "Post-condition failed: Task completed; exit code 0; expected outputs created"
+```
+
+---
+
+## Acceptance Criteria
+
+**Purpose:** Definitive pass/fail criteria for task completion
+
+**Checklist:**
+
+```yaml
+acceptance-criteria:
+  - [ ] Task completed as expected; side effects documented
+    tipo: acceptance-criterion
+    blocker: true
+    validação: |
+      Assert task completed as expected; side effects documented
+    error_message: "Acceptance criterion not met: Task completed as expected; side effects documented"
+```
+
+---
+
+## Tools
+
+**External/shared resources used by this task:**
+
+- **Tool:** task-runner
+  - **Purpose:** Task execution and orchestration
+  - **Source:** .aios-core/core/task-runner.js
+
+- **Tool:** logger
+  - **Purpose:** Execution logging and error tracking
+  - **Source:** .aios-core/utils/logger.js
+
+---
+
+## Scripts
+
+**Agent-specific code for this task:**
+
+- **Script:** execute-task.js
+  - **Purpose:** Generic task execution wrapper
+  - **Language:** JavaScript
+  - **Location:** .aios-core/scripts/execute-task.js
+
+---
+
+## Error Handling
+
+**Strategy:** retry
+
+**Common Errors:**
+
+1. **Error:** Task Not Found
+   - **Cause:** Specified task not registered in system
+   - **Resolution:** Verify task name and registration
+   - **Recovery:** List available tasks, suggest similar
+
+2. **Error:** Invalid Parameters
+   - **Cause:** Task parameters do not match expected schema
+   - **Resolution:** Validate parameters against task definition
+   - **Recovery:** Provide parameter template, reject execution
+
+3. **Error:** Execution Timeout
+   - **Cause:** Task exceeds maximum execution time
+   - **Resolution:** Optimize task or increase timeout
+   - **Recovery:** Kill task, cleanup resources, log state
+
+---
+
+## Performance
+
+**Expected Metrics:**
+
+```yaml
+duration_expected: 2-5 min (estimated)
+cost_estimated: $0.001-0.003
+token_usage: ~1,000-3,000 tokens
+```
+
+**Optimization Notes:**
+- Parallelize independent operations; reuse atom results; implement early exits
+
+---
+
+## Metadata
+
+```yaml
+story: N/A
+version: 1.0.0
+dependencies:
+  - N/A
+tags:
+  - automation
+  - workflow
+updated_at: 2025-11-17
+```
+
+---
+
+# No checklists needed - this task manages real-time collaborative editing sessions, no document validation required
+tools:
+  - github-cli
+---
+
+# Collaborative Edit - AIOS Developer Task
+
+## Purpose
+Create and manage collaborative editing sessions for real-time component modification with multiple participants.
+
+## Command Pattern
+```
+*collaborative-edit <action> [options]
+```
+
+## Actions
+- `start`: Start a new collaborative editing session
+- `join`: Join an existing session
+- `leave`: Leave current session
+- `end`: End a collaborative session
+- `status`: Check session status
+
+## Parameters
+### Start Session
+- `--component <path>`: Component to edit collaboratively
+- `--participants <users>`: Initial participants (comma-separated)
+- `--mode <mode>`: Editing mode (live, turn-based, review)
+- `--timeout <minutes>`: Session timeout
+
+### Join Session
+- `--session-id <id>`: Session ID to join
+- `--role <role>`: Participant role (editor, reviewer, observer)
+
+## Examples
+```bash
+# Start collaborative editing session
+*collaborative-edit start --component aios-core/agents/data-agent.md --participants alice,bob --mode live
+
+# Join existing session
+*collaborative-edit join --session-id session-1234567890 --role editor
+
+# Check session status
+*collaborative-edit status --session-id session-1234567890
+
+# End session and merge changes
+*collaborative-edit end --session-id session-1234567890 --merge-strategy collaborative
+```
+
+## Implementation
+
+```javascript
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const EventEmitter = require('events');
+
+class CollaborativeEditTask extends EventEmitter {
+  constructor() {
+    super();
+    this.taskName = 'collaborative-edit';
+    this.description = 'Manage collaborative editing sessions';
+    this.rootPath = process.cwd();
+    this.sessionDir = path.join(this.rootPath, '.aios', 'sessions');
+    this.synchronizer = null;
+    this.conflictManager = null;
+    this.currentSession = null;
+    this.editHistory = [];
+  }
+
+  async execute(params) {
+    try {
+      console.log(chalk.blue('👥 AIOS Collaborative Editing'));
+      console.log(chalk.gray('Real-time collaborative modification system\n'));
+
+      // Parse action and parameters
+      const { action, config } = await this.parseParameters(params);
+      
+      // Initialize dependencies
+      await this.initializeDependencies();
+
+      // Execute action
+      let result;
+      switch (action) {
+        case 'start':
+          result = await this.startSession(config);
+          break;
+        case 'join':
+          result = await this.joinSession(config);
+          break;
+        case 'leave':
+          result = await this.leaveSession(config);
+          break;
+        case 'end':
+          result = await this.endSession(config);
+          break;
+        case 'status':
+          result = await this.getSessionStatus(config);
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+
+      return result;
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Collaborative edit failed: ${error.message}`));
+      throw error;
+    }
+  }
+
+  async parseParameters(params) {
+    if (params.length < 1) {
+      throw new Error('Usage: *collaborative-edit <action> [options]');
+    }
+
+    const action = params[0];
+    const config = {
+      sessionId: null,
+      componentPath: null,
+      participants: [],
+      mode: 'live',
+      timeout: 60,
+      role: 'editor',
+      mergeStrategy: 'collaborative'
+    };
+
+    // Parse options
+    for (let i = 1; i < params.length; i++) {
+      const param = params[i];
+      
+      if (param.startsWith('--session-id') && params[i + 1]) {
+        config.sessionId = params[++i];
+      } else if (param.startsWith('--component') && params[i + 1]) {
+        config.componentPath = params[++i];
+      } else if (param.startsWith('--participants') && params[i + 1]) {
+        config.participants = params[++i].split(',').map(p => p.trim());
+      } else if (param.startsWith('--mode') && params[i + 1]) {
+        config.mode = params[++i];
+      } else if (param.startsWith('--timeout') && params[i + 1]) {
+        config.timeout = parseInt(params[++i]);
+      } else if (param.startsWith('--role') && params[i + 1]) {
+        config.role = params[++i];
+      } else if (param.startsWith('--merge-strategy') && params[i + 1]) {
+        config.mergeStrategy = params[++i];
+      }
+    }
+
+    // Validate action
+    const validActions = ['start', 'join', 'leave', 'end', 'status'];
+    if (!validActions.includes(action)) {
+      throw new Error(`Invalid action: ${action}. Must be one of: ${validActions.join(', ')}`);
+    }
+
+    return { action, config };
+  }
+
+  async initializeDependencies() {
+    // const ModificationSynchronizer = require('../scripts/modification-synchronizer'); // Archived in archived-utilities/ (Story 3.1.3)
+    // this.synchronizer = new ModificationSynchronizer({ rootPath: this.rootPath }); // Archived in archived-utilities/ (Story 3.1.3)
+    // await this.synchronizer.initialize(); // Archived in archived-utilities/ (Story 3.1.3)
+
+    // const ConflictManager = require('../scripts/conflict-manager'); // Archived in archived-utilities/ (Story 3.1.2)
+    // this.conflictManager = new ConflictManager({ rootPath: this.rootPath }); // Archived in archived-utilities/ (Story 3.1.2)
+
+    await fs.mkdir(this.sessionDir, { recursive: true });
+  }
+
+  async startSession(config) {
+    console.log(chalk.blue('🚀 Starting collaborative session...'));
+
+    // Validate component exists
+    const component = await this.validateComponent(config.componentPath);
+
+    // Generate session ID
+    const sessionId = `session-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
+
+    // Create session
+    const session = {
+      id: sessionId,
+      componentPath: config.componentPath,
+      componentType: component.type,
+      participants: [
+        {
+          id: process.env.USER || 'initiator',
+          role: 'owner',
+          joinedAt: new Date().toISOString(),
+          status: 'active'
+        }
+      ],
+      mode: config.mode,
+      status: 'active',
+      createdAt: new Date().toISOString(),
+      timeout: config.timeout,
+      editHistory: [],
+      locks: new Map(),
+      metadata: {
+        originalContent: component.content,
+        currentContent: component.content,
+        version: 0
+      }
+    };
+
+    // Add initial participants
+    for (const participant of config.participants) {
+      if (participant !== session.participants[0].id) {
+        session.participants.push({
+          id: participant,
+          role: 'editor',
+          joinedAt: new Date().toISOString(),
+          status: 'invited'
+        });
+      }
+    }
+
+    // Save session
+    await this.saveSession(session);
+
+    // Start synchronization
+    await this.synchronizer.startSync();
+    
+    // Create collaborative workspace
+    await this.createCollaborativeWorkspace(session);
+
+    // Set as current session
+    this.currentSession = session;
+
+    // Start real-time monitoring
+    this.startRealtimeMonitoring(session);
+
+    console.log(chalk.green('\n✅ Collaborative session created'));
+    console.log(chalk.gray(`   Session ID: ${sessionId}`));
+    console.log(chalk.gray(`   Component: ${config.componentPath}`));
+    console.log(chalk.gray(`   Mode: ${config.mode}`));
+    console.log(chalk.gray(`   Participants: ${session.participants.length}`));
+    
+    if (config.mode === 'live') {
+      console.log(chalk.blue('\n📡 Live editing enabled - changes sync in real-time'));
+    }
+
+    return {
+      success: true,
+      sessionId: sessionId,
+      componentPath: config.componentPath,
+      participants: session.participants,
+      mode: config.mode,
+      workspace: await this.getWorkspaceInfo(session)
+    };
+  }
+
+  async joinSession(config) {
+    if (!config.sessionId) {
+      throw new Error('Session ID required to join');
+    }
+
+    console.log(chalk.blue(`🔗 Joining session ${config.sessionId}...`));
+
+    // Load session
+    const session = await this.loadSession(config.sessionId);
+    
+    if (session.status !== 'active') {
+      throw new Error('Session is not active');
+    }
+
+    // Check if already participant
+    const participantId = process.env.USER || 'user';
+    let participant = session.participants.find(p => p.id === participantId);
+    
+    if (!participant) {
+      // Add new participant
+      participant = {
+        id: participantId,
+        role: config.role,
+        joinedAt: new Date().toISOString(),
+        status: 'active'
+      };
+      session.participants.push(participant);
+    } else {
+      // Update existing participant
+      participant.status = 'active';
+      participant.role = config.role;
+    }
+
+    // Update session
+    await this.saveSession(session);
+
+    // Set as current session
+    this.currentSession = session;
+
+    // Subscribe to updates
+    await this.subscribeToSessionUpdates(session);
+
+    // Load current state
+    const workspace = await this.loadWorkspace(session);
+
+    console.log(chalk.green('\n✅ Joined collaborative session'));
+    console.log(chalk.gray(`   Role: ${config.role}`));
+    console.log(chalk.gray(`   Active participants: ${session.participants.filter(p => p.status === 'active').length}`));
+    console.log(chalk.gray(`   Current version: ${session.metadata.version}`));
+
+    // Show current editing status
+    if (session.mode === 'turn-based') {
+      const currentEditor = this.getCurrentEditor(session);
+      console.log(chalk.yellow(`\n⏳ Current editor: ${currentEditor || 'None'}`));
+    }
+
+    return {
+      success: true,
+      sessionId: session.id,
+      role: config.role,
+      workspace: workspace,
+      participants: session.participants.filter(p => p.status === 'active')
+    };
+  }
+
+  async leaveSession(config) {
+    const sessionId = config.sessionId || (this.currentSession && this.currentSession.id);
+    
+    if (!sessionId) {
+      throw new Error('No active session to leave');
+    }
+
+    console.log(chalk.blue(`👋 Leaving session ${sessionId}...`));
+
+    // Load session
+    const session = await this.loadSession(sessionId);
+    
+    // Update participant status
+    const participantId = process.env.USER || 'user';
+    const participant = session.participants.find(p => p.id === participantId);
+    
+    if (participant) {
+      participant.status = 'left';
+      participant.leftAt = new Date().toISOString();
+    }
+
+    // Save any pending changes
+    if (this.currentSession && this.editHistory.length > 0) {
+      await this.saveEditHistory(session);
+    }
+
+    // Update session
+    await this.saveSession(session);
+
+    // Clear current session
+    this.currentSession = null;
+
+    console.log(chalk.green('✅ Left collaborative session'));
+
+    return {
+      success: true,
+      sessionId: sessionId
+    };
+  }
+
+  async endSession(config) {
+    if (!config.sessionId) {
+      throw new Error('Session ID required to end session');
+    }
+
+    console.log(chalk.blue(`🏁 Ending session ${config.sessionId}...`));
+
+    // Load session
+    const session = await this.loadSession(config.sessionId);
+    
+    // Check permissions
+    const participantId = process.env.USER || 'user';
+    const participant = session.participants.find(p => p.id === participantId);
+    
+    if (!participant || participant.role !== 'owner') {
+      throw new Error('Only session owner can end the session');
+    }
+
+    // Finalize all pending edits
+    await this.finalizeEdits(session);
+
+    // Merge changes
+    console.log(chalk.gray('Merging collaborative changes...'));
+    const mergeResult = await this.mergeCollaborativeChanges(session, config.mergeStrategy);
+
+    // Update session status
+    session.status = 'completed';
+    session.endedAt = new Date().toISOString();
+    session.mergeResult = mergeResult;
+
+    // Save final session state
+    await this.saveSession(session);
+
+    // Stop synchronization
+    await this.synchronizer.stopSync();
+
+    // Archive session
+    await this.archiveSession(session);
+
+    console.log(chalk.green('\n✅ Collaborative session ended'));
+    console.log(chalk.gray(`   Total edits: ${session.editHistory.length}`));
+    console.log(chalk.gray(`   Participants: ${session.participants.length}`));
+    console.log(chalk.gray(`   Duration: ${this.calculateDuration(session)}`));
+    
+    if (mergeResult.success) {
+      console.log(chalk.green(`   Changes merged successfully`));
+    }
+
+    return {
+      success: true,
+      sessionId: session.id,
+      mergeResult: mergeResult,
+      statistics: this.getSessionStatistics(session)
+    };
+  }
+
+  async getSessionStatus(config) {
+    const sessionId = config.sessionId || (this.currentSession && this.currentSession.id);
+    
+    if (!sessionId) {
+      // Show all active sessions
+      return await this.listActiveSessions();
+    }
+
+    // Load specific session
+    const session = await this.loadSession(sessionId);
+    
+    console.log(chalk.blue('\n📊 Session Status'));
+    console.log(chalk.gray('━'.repeat(50)));
+    
+    console.log(`ID: ${chalk.white(session.id)}`);
+    console.log(`Component: ${chalk.white(session.componentPath)}`);
+    console.log(`Status: ${this.formatStatus(session.status)}`);
+    console.log(`Mode: ${chalk.white(session.mode)}`);
+    console.log(`Created: ${chalk.white(new Date(session.createdAt).toLocaleString())}`);
+    
+    console.log(chalk.blue('\n👥 Participants:'));
+    session.participants.forEach(p => {
+      const status = p.status === 'active' ? chalk.green('●') : chalk.gray('○');
+      console.log(`  ${status} ${p.id} (${p.role})`);
+    });
+
+    console.log(chalk.blue('\n📝 Edit History:'));
+    console.log(`  Total edits: ${session.editHistory.length}`);
+    console.log(`  Current version: ${session.metadata.version}`);
+    
+    if (session.editHistory.length > 0) {
+      const recentEdits = session.editHistory.slice(-5);
+      console.log('  Recent edits:');
+      recentEdits.forEach(edit => {
+        console.log(`    - ${edit.author} at ${new Date(edit.timestamp).toLocaleTimeString()}`);
+      });
+    }
+
+    if (session.mode === 'turn-based') {
+      const currentEditor = this.getCurrentEditor(session);
+      console.log(chalk.yellow(`\n⏳ Current turn: ${currentEditor || 'None'}`));
+    }
+
+    return {
+      success: true,
+      session: session,
+      activeParticipants: session.participants.filter(p => p.status === 'active').length,
+      isCurrentSession: sessionId === (this.currentSession && this.currentSession.id)
+    };
+  }
+
+  // Helper methods
+
+  async validateComponent(componentPath) {
+    const fullPath = path.resolve(this.rootPath, componentPath);
+    
+    try {
+      const stats = await fs.stat(fullPath);
+      if (!stats.isFile()) {
+        throw new Error('Component path must be a file');
+      }
+
+      const content = await fs.readFile(fullPath, 'utf-8');
+      const type = this.detectComponentType(fullPath);
+
+      return {
+        path: componentPath,
+        fullPath: fullPath,
+        type: type,
+        content: content,
+        size: stats.size
+      };
+
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Component not found: ${componentPath}`);
+      }
+      throw error;
+    }
+  }
+
+  detectComponentType(filePath) {
+    if (filePath.includes('/agents/')) return 'agent';
+    if (filePath.includes('/tasks/')) return 'task';
+    if (filePath.includes('/workflows/')) return 'workflow';
+    if (filePath.includes('/utils/')) return 'util';
+    return 'unknown';
+  }
+
+  async saveSession(session) {
+    const sessionFile = path.join(this.sessionDir, `${session.id}.json`);
+    await fs.writeFile(sessionFile, JSON.stringify(session, null, 2));
+  }
+
+  async loadSession(sessionId) {
+    const sessionFile = path.join(this.sessionDir, `${sessionId}.json`);
+    
+    try {
+      const content = await fs.readFile(sessionFile, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      throw error;
+    }
+  }
+
+  async createCollaborativeWorkspace(session) {
+    const workspaceDir = path.join(this.sessionDir, session.id, 'workspace');
+    await fs.mkdir(workspaceDir, { recursive: true });
+
+    // Create working copy
+    const workingFile = path.join(workspaceDir, 'working.txt');
+    await fs.writeFile(workingFile, session.metadata.originalContent);
+
+    // Create version history
+    const versionDir = path.join(workspaceDir, 'versions');
+    await fs.mkdir(versionDir, { recursive: true });
+    
+    const v0File = path.join(versionDir, 'v0.txt');
+    await fs.writeFile(v0File, session.metadata.originalContent);
+
+    // Create edit log
+    const editLog = path.join(workspaceDir, 'edits.jsonl');
+    await fs.writeFile(editLog, '');
+
+    return workspaceDir;
+  }
+
+  async loadWorkspace(session) {
+    const workspaceDir = path.join(this.sessionDir, session.id, 'workspace');
+    const workingFile = path.join(workspaceDir, 'working.txt');
+    
+    const currentContent = await fs.readFile(workingFile, 'utf-8');
+    
+    return {
+      workspaceDir: workspaceDir,
+      currentContent: currentContent,
+      version: session.metadata.version,
+      lastEdit: session.editHistory.length > 0 ? 
+        session.editHistory[session.editHistory.length - 1] : null
+    };
+  }
+
+  startRealtimeMonitoring(session) {
+    if (session.mode !== 'live') return;
+
+    // Set up file watcher for workspace
+    const workspaceDir = path.join(this.sessionDir, session.id, 'workspace');
+    const workingFile = path.join(workspaceDir, 'working.txt');
+
+    // Monitor for changes
+    let lastContent = session.metadata.currentContent;
+    
+    this.monitorInterval = setInterval(async () => {
+      try {
+        const currentContent = await fs.readFile(workingFile, 'utf-8');
+        if (currentContent !== lastContent) {
+          // Detect and broadcast changes
+          const edit = {
+            id: `edit-${Date.now()}`,
+            author: process.env.USER || 'unknown',
+            timestamp: new Date().toISOString(),
+            type: 'content_change',
+            diff: this.generateDiff(lastContent, currentContent)
+          };
+
+          await this.broadcastEdit(session, edit);
+          lastContent = currentContent;
+        }
+      } catch (error) {
+        // Workspace may have been cleaned up
+      }
+    }, 1000); // Check every second
+  }
+
+  async subscribeToSessionUpdates(session) {
+    // Subscribe to edit broadcasts
+    const editLog = path.join(this.sessionDir, session.id, 'workspace', 'edits.jsonl');
+    
+    // Watch for new edits
+    let lastSize = 0;
+    this.watchInterval = setInterval(async () => {
+      try {
+        const stats = await fs.stat(editLog);
+        if (stats.size > lastSize) {
+          // Read new edits
+          const content = await fs.readFile(editLog, 'utf-8');
+          const lines = content.trim().split('\n');
+          const newEdits = lines.slice(this.editHistory.length);
+          
+          for (const line of newEdits) {
+            if (line) {
+              const edit = JSON.parse(line);
+              await this.applyRemoteEdit(session, edit);
+              this.editHistory.push(edit);
+            }
+          }
+          
+          lastSize = stats.size;
+        }
+      } catch (error) {
+        // Edit log may not exist yet
+      }
+    }, 500); // Check every 500ms
+  }
+
+  async broadcastEdit(session, edit) {
+    // Add to session history
+    session.editHistory.push(edit);
+    session.metadata.version++;
+    
+    // Write to edit log
+    const editLog = path.join(this.sessionDir, session.id, 'workspace', 'edits.jsonl');
+    await fs.appendFile(editLog, JSON.stringify(edit) + '\n');
+    
+    // Save session state
+    await this.saveSession(session);
+    
+    // Emit event
+    this.emit('edit_broadcast', { sessionId: session.id, edit });
+  }
+
+  async applyRemoteEdit(session, edit) {
+    if (edit.author === (process.env.USER || 'unknown')) {
+      return; // Skip own edits
+    }
+
+    console.log(chalk.gray(`📝 ${edit.author} made changes`));
+
+    // Apply edit to workspace
+    const workingFile = path.join(this.sessionDir, session.id, 'workspace', 'working.txt');
+    
+    if (edit.type === 'content_change' && edit.content) {
+      await fs.writeFile(workingFile, edit.content);
+    }
+  }
+
+  generateDiff(oldContent, newContent) {
+    // Simple diff generation
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    
+    const diff = {
+      additions: 0,
+      deletions: 0,
+      changes: []
+    };
+    
+    // Compare lines
+    const maxLines = Math.max(oldLines.length, newLines.length);
+    for (let i = 0; i < maxLines; i++) {
+      if (oldLines[i] !== newLines[i]) {
+        if (i >= oldLines.length) {
+          diff.additions++;
+          diff.changes.push({ type: 'add', line: i, content: newLines[i] });
+        } else if (i >= newLines.length) {
+          diff.deletions++;
+          diff.changes.push({ type: 'delete', line: i, content: oldLines[i] });
+        } else {
+          diff.changes.push({ type: 'modify', line: i, old: oldLines[i], new: newLines[i] });
+        }
+      }
+    }
+    
+    return diff;
+  }
+
+  getCurrentEditor(session) {
+    if (session.mode !== 'turn-based') return null;
+    
+    // Find current turn holder
+    const activeTurn = session.editHistory.find(edit => 
+      edit.type === 'turn_taken' && !edit.completed
+    );
+    
+    return activeTurn ? activeTurn.author : null;
+  }
+
+  async saveEditHistory(session) {
+    // Save current edit state
+    const workspaceDir = path.join(this.sessionDir, session.id, 'workspace');
+    const versionDir = path.join(workspaceDir, 'versions');
+    
+    const versionFile = path.join(versionDir, `v${session.metadata.version}.txt`);
+    const workingFile = path.join(workspaceDir, 'working.txt');
+    
+    const content = await fs.readFile(workingFile, 'utf-8');
+    await fs.writeFile(versionFile, content);
+  }
+
+  async finalizeEdits(session) {
+    // Ensure all edits are saved
+    await this.saveEditHistory(session);
+    
+    // Clear any locks
+    session.locks = new Map();
+    
+    // Mark all participants as inactive
+    session.participants.forEach(p => {
+      if (p.status === 'active') {
+        p.status = 'completed';
+      }
+    });
+  }
+
+  async mergeCollaborativeChanges(session, strategy) {
+    const result = {
+      success: false,
+      finalContent: null,
+      mergeDetails: []
+    };
+
+    try {
+      const workingFile = path.join(this.sessionDir, session.id, 'workspace', 'working.txt');
+      const finalContent = await fs.readFile(workingFile, 'utf-8');
+      
+      // Apply to actual component
+      const componentPath = path.resolve(this.rootPath, session.componentPath);
+      await fs.writeFile(componentPath, finalContent);
+      
+      result.success = true;
+      result.finalContent = finalContent;
+      result.mergeDetails.push(`Applied final collaborative edits using ${strategy} strategy`);
+      
+    } catch (error) {
+      result.mergeDetails.push(`Merge failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  calculateDuration(session) {
+    const start = new Date(session.createdAt);
+    const end = session.endedAt ? new Date(session.endedAt) : new Date();
+    
+    const duration = end - start;
+    const minutes = Math.floor(duration / 60000);
+    const hours = Math.floor(minutes / 60);
+    
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m`;
+    }
+    return `${minutes}m`;
+  }
+
+  async archiveSession(session) {
+    const archiveDir = path.join(this.sessionDir, 'archive');
+    await fs.mkdir(archiveDir, { recursive: true });
+    
+    const archiveFile = path.join(archiveDir, `${session.id}.json`);
+    await fs.writeFile(archiveFile, JSON.stringify(session, null, 2));
+    
+    // Clean up active session files
+    const sessionFile = path.join(this.sessionDir, `${session.id}.json`);
+    await fs.unlink(sessionFile);
+  }
+
+  async listActiveSessions() {
+    console.log(chalk.blue('\n📋 Active Collaborative Sessions'));
+    console.log(chalk.gray('━'.repeat(50)));
+    
+    const files = await fs.readdir(this.sessionDir);
+    const sessions = [];
+    
+    for (const file of files) {
+      if (file.endsWith('.json') && !file.startsWith('archive')) {
+        try {
+          const session = await this.loadSession(file.replace('.json', ''));
+          if (session.status === 'active') {
+            sessions.push(session);
+          }
+        } catch (error) {
+          // Skip invalid files
+        }
+      }
+    }
+    
+    if (sessions.length === 0) {
+      console.log(chalk.gray('No active sessions'));
+    } else {
+      sessions.forEach(session => {
+        console.log(`\n${chalk.white(session.id)}`);
+        console.log(`  Component: ${session.componentPath}`);
+        console.log(`  Mode: ${session.mode}`);
+        console.log(`  Participants: ${session.participants.filter(p => p.status === 'active').length}`);
+        console.log(`  Started: ${new Date(session.createdAt).toLocaleString()}`);
+      });
+    }
+    
+    return {
+      success: true,
+      activeSessions: sessions.length,
+      sessions: sessions.map(s => ({
+        id: s.id,
+        component: s.componentPath,
+        participants: s.participants.length,
+        mode: s.mode
+      }))
+    };
+  }
+
+  getSessionStatistics(session) {
+    const stats = {
+      totalEdits: session.editHistory.length,
+      participants: session.participants.length,
+      activeParticipants: session.participants.filter(p => p.status === 'active').length,
+      duration: this.calculateDuration(session),
+      editsByAuthor: {}
+    };
+    
+    // Count edits by author
+    session.editHistory.forEach(edit => {
+      if (!stats.editsByAuthor[edit.author]) {
+        stats.editsByAuthor[edit.author] = 0;
+      }
+      stats.editsByAuthor[edit.author]++;
+    });
+    
+    return stats;
+  }
+
+  formatStatus(status) {
+    const statusMap = {
+      active: chalk.green('ACTIVE'),
+      completed: chalk.blue('COMPLETED'),
+      cancelled: chalk.red('CANCELLED'),
+      error: chalk.red('ERROR')
+    };
+    return statusMap[status] || status;
+  }
+
+  // Cleanup
+  cleanup() {
+    if (this.monitorInterval) {
+      clearInterval(this.monitorInterval);
+    }
+    if (this.watchInterval) {
+      clearInterval(this.watchInterval);
+    }
+  }
+}
+
+module.exports = CollaborativeEditTask;
+```
+
+## Validation Rules
+
+### Session Management
+- Only one active session per component allowed
+- Session owner has administrative privileges
+- Participants must be invited or have appropriate permissions
+- Sessions timeout after specified duration
+- All edits must be tracked and versioned
+
+### Editing Modes
+- **Live**: Real-time collaborative editing with instant sync
+- **Turn-based**: Sequential editing with explicit turn management
+- **Review**: Changes require approval before applying
+
+### Conflict Prevention
+- Automatic locking for turn-based editing
+- Real-time conflict detection for live editing
+- Version tracking for all changes
+- Rollback capability for problematic edits
+
+## Integration Points
+
+### Modification Synchronizer
+- Handles real-time synchronization of edits
+- Manages edit broadcasting and receiving
+- Tracks version consistency
+- Handles network interruptions
+
+### Conflict Manager
+- Detects and resolves editing conflicts
+- Manages locks and turn-based access
+- Handles merge strategies
+- Provides conflict visualization
+
+### Notification Service
+- Notifies participants of session events
+- Alerts on turn changes
+- Broadcasts edit notifications
+- Handles session invitations
+
+## Security Considerations
+- Validate participant permissions
+- Encrypt sensitive session data
+- Audit all collaborative actions
+- Prevent unauthorized access to sessions
 - Secure communication channels