grimoire-framework 1.0.0

package/.grimoire/development/tasks/collaborative-edit.md

@@ -0,0 +1,1110 @@
+---
+
+# 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 (grimoire 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:** .grimoire/core/task-runner.js
+
+- **Tool:** logger
+  - **Purpose:** Execution logging and error tracking
+  - **Source:** .grimoire/utils/logger.js
+
+---
+
+## Scripts
+
+**Agent-specific code for this task:**
+
+- **Script:** execute-task.js
+  - **Purpose:** Generic task execution wrapper
+  - **Language:** JavaScript
+  - **Location:** .grimoire/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 - grimoire 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 grimoire/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, '.grimoire', 'sessions');
+    this.synchronizer = null;
+    this.conflictManager = null;
+    this.currentSession = null;
+    this.editHistory = [];
+  }
+
+  async execute(params) {
+    try {
+      console.log(chalk.blue('👥 grimoire 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 
+