s9n-devops-agent 1.1.0 → 1.2.1

package/README.md

@@ -23,6 +23,7 @@ An intelligent Git automation system with multi-agent support, session managemen
 - **⚙️ VS Code Integration**: Seamlessly integrates with VS Code tasks
 - **🔐 Safe Concurrent Development**: Multiple agents can work simultaneously without conflicts
 - **🏷️ Smart Branching**: Automatic branch creation with configurable naming patterns
+- **🐋 Docker Auto-Restart**: Automatically restart Docker containers after code push (v1.2.0)
 
 ## Installation 📦
 
@@ -96,9 +97,9 @@ s9n-devops-agent start
 s9n-devops-agent create --task "implement-api"
 ```
 
-### Working with AI Development Agents
+### Working with AI Assistants
 
-When you start a session, you'll receive instructions to paste into your AI development agent (Claude, Cursor, Cline, GitHub Copilot, etc.):
+When you start a session, you'll receive instructions to paste into your AI assistant:
 
 ```
 I'm working in a DevOps-managed session with the following setup:
@@ -186,9 +187,9 @@ Configuration is stored in:
    # Enter task: implement-authentication
    ```
 
-2. **Copy Instructions to AI Development Agent**:
-   - The tool provides instructions to paste into your AI agent (Claude, Cursor, Cline, etc.)
-   - The AI agent works in the isolated worktree
+2. **Copy Instructions to AI Assistant**:
+   - The tool provides instructions to paste into Claude/Copilot
+   - The AI works in the isolated worktree
 
 3. **AI Makes Changes**:
    - AI writes code in the worktree directory
@@ -226,6 +227,30 @@ Add to `.vscode/tasks.json`:
 
 ## Advanced Features 🔬
 
+### Docker Container Auto-Restart (v1.2.0+)
+
+Automatically restart Docker containers after pushing code changes:
+
+```bash
+# During session creation, if docker-compose is detected:
+s9n-devops-agent start
+# -> Auto-restart Docker containers after push? (y/N): y
+# -> Rebuild containers on restart? (y/N): n
+# -> Specific service to restart (leave empty for all): app
+```
+
+**Features:**
+- Detects docker-compose files automatically
+- Optional container rebuild on restart
+- Target specific services or restart all
+- Non-blocking: Docker failures don't affect git workflow
+- Works with Docker Compose v1 and v2
+
+**Supported docker-compose files:**
+- docker-compose.yml / docker-compose.yaml
+- compose.yml / compose.yaml
+- docker-compose.dev.yml / docker-compose.local.yml
+
 ### Multi-Agent Collaboration
 
 Multiple AI assistants can work on different features simultaneously:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s9n-devops-agent",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "CS_DevOpsAgent - Intelligent Git Automation System with multi-agent support and session management",
   "type": "module",
   "main": "src/cs-devops-agent-worker.js",

package/src/cs-devops-agent-worker.js

@@ -113,6 +113,8 @@ import chokidar from "chokidar";
 import { execa } from "execa";
 import readline from "node:readline";
 import { stdin as input, stdout as output } from 'node:process';
+import { execSync } from 'child_process';
+import { restartDockerContainers } from './docker-utils.js';
 
 // ============================================================================
 // CONFIGURATION SECTION - All settings can be overridden via environment vars
@@ -762,7 +764,12 @@ async function commitOnce(repoRoot, msgPath) {
     if (PUSH) {
       const ok = await pushBranch(BRANCH);
       log(`push ${ok ? "ok" : "failed"}`);
-      if (ok && CLEAR_MSG_WHEN === "push") clearMsgFile(msgPath);
+      if (ok) {
+        if (CLEAR_MSG_WHEN === "push") clearMsgFile(msgPath);
+        
+        // Handle Docker restart if configured
+        await handleDockerRestart();
+      }
     }
   } finally {
     busy = false;
@@ -782,6 +789,52 @@ function schedule(repoRoot, msgPath) {
   }, QUIET_MS);
 }
 
+// ============================================================================
+// DOCKER CONTAINER MANAGEMENT
+// ============================================================================
+
+/**
+ * Handle Docker container restart if configured in session
+ */
+async function handleDockerRestart() {
+  // Check if we're in a session with Docker configuration
+  const sessionConfigPath = path.join(process.cwd(), '.devops-session.json');
+  if (!fs.existsSync(sessionConfigPath)) {
+    return; // Not in a managed session
+  }
+  
+  try {
+    const sessionConfig = JSON.parse(fs.readFileSync(sessionConfigPath, 'utf8'));
+    
+    // Check if Docker restart is enabled
+    if (!sessionConfig.dockerConfig || !sessionConfig.dockerConfig.enabled) {
+      return;
+    }
+    
+    log('🐋 Docker restart configured - initiating container restart...');
+    
+    const dockerOptions = {
+      projectPath: process.cwd(),
+      composeFile: sessionConfig.dockerConfig.composeFile,
+      serviceName: sessionConfig.dockerConfig.service,
+      rebuild: sessionConfig.dockerConfig.rebuild,
+      forceRecreate: sessionConfig.dockerConfig.forceRecreate || false,
+      detach: true
+    };
+    
+    const result = await restartDockerContainers(dockerOptions);
+    
+    if (result.success) {
+      log('✅ Docker containers restarted successfully');
+    } else {
+      log(`⚠️ Docker restart failed: ${result.error}`);
+    }
+  } catch (error) {
+    // Don't fail the commit/push if Docker restart fails
+    dlog('Docker restart error:', error.message);
+  }
+}
+
 // ============================================================================
 // INFRASTRUCTURE CHANGE DETECTION
 // ============================================================================
@@ -1604,17 +1657,71 @@ console.log();
           fs.unlinkSync(msgPath);
         }
         
-        // Create cleanup marker if in a session
+        // Handle worktree cleanup if in a session
         if (sessionId) {
-          const cleanupMarker = path.join(process.cwd(), '.session-cleanup-requested');
-          fs.writeFileSync(cleanupMarker, JSON.stringify({
-            sessionId: sessionId,
-            timestamp: new Date().toISOString(),
-            branch: await currentBranch(),
-            worktree: process.cwd()
-          }, null, 2));
-          console.log("\n✓ Session cleanup complete.");
-          console.log("Run 'npm run devops:close' from the main repo to remove the worktree.");
+          const currentDir = process.cwd();
+          const isWorktree = currentDir.includes('local_deploy/worktrees');
+          
+          if (isWorktree) {
+            console.log("\n" + "=".repeat(60));
+            console.log("WORKTREE CLEANUP");
+            console.log("=".repeat(60));
+            console.log("\nThis session is running in a worktree:");
+            console.log(`  ${currentDir}`);
+            console.log("\nWould you like to remove this worktree now?");
+            console.log("  y/yes - Remove worktree and close session");
+            console.log("  n/no  - Keep worktree for later use");
+            console.log("  (You can remove it later with: node src/session-coordinator.js close " + sessionId + ")");
+            
+            rl.prompt();
+            const cleanupAnswer = await new Promise(resolve => {
+              rl.once('line', resolve);
+            });
+            
+            if (cleanupAnswer.toLowerCase() === 'y' || cleanupAnswer.toLowerCase() === 'yes') {
+              console.log("\nRemoving worktree...");
+              
+              // Get the main repo root (parent of worktree)
+              const repoRoot = path.resolve(currentDir, '../../../');
+              
+              try {
+                // Switch to main repo directory first
+                process.chdir(repoRoot);
+                
+                // Remove the worktree
+                execSync(`git worktree remove "${currentDir}" --force`, { stdio: 'inherit' });
+                console.log("✓ Worktree removed successfully");
+                
+                // Remove session lock file
+                const lockFile = path.join(repoRoot, 'local_deploy', 'session-locks', `${sessionId}.lock`);
+                if (fs.existsSync(lockFile)) {
+                  fs.unlinkSync(lockFile);
+                  console.log("✓ Session closed");
+                }
+              } catch (err) {
+                console.error("\nCould not remove worktree automatically.");
+                console.error("Error: " + err.message);
+                console.log("\nTo remove it manually, run from the main repo:");
+                console.log(`  git worktree remove "${currentDir}" --force`);
+                console.log("  OR");
+                console.log(`  node src/session-coordinator.js close ${sessionId}`);
+              }
+            } else {
+              // Create cleanup marker for later
+              const cleanupMarker = path.join(currentDir, '.session-cleanup-requested');
+              fs.writeFileSync(cleanupMarker, JSON.stringify({
+                sessionId: sessionId,
+                timestamp: new Date().toISOString(),
+                branch: await currentBranch(),
+                worktree: currentDir
+              }, null, 2));
+              console.log("\n✓ Session marked for later cleanup.");
+              console.log("To remove the worktree later, run from the main repo:");
+              console.log(`  node src/session-coordinator.js close ${sessionId}`);
+            }
+          } else {
+            console.log("\n✓ Session cleanup complete.");
+          }
         }
         
         console.log("\nGoodbye!");

package/src/docker-utils.js

@@ -0,0 +1,290 @@
+/**
+ * ============================================================================
+ * DOCKER UTILITIES FOR DEVOPS AGENT
+ * ============================================================================
+ * 
+ * PURPOSE:
+ * Provides Docker container management functionality for automatic restarts
+ * after code pushes. Integrates with the DevOps agent session workflow.
+ * 
+ * ============================================================================
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execa } from 'execa';
+
+/**
+ * Check if Docker is installed and running
+ */
+export async function isDockerAvailable() {
+  try {
+    await execa('docker', ['version'], { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if docker-compose is available
+ */
+export async function isDockerComposeAvailable() {
+  try {
+    // Try docker compose (v2)
+    await execa('docker', ['compose', 'version'], { stdio: 'pipe' });
+    return 'docker compose';
+  } catch {
+    try {
+      // Try docker-compose (v1)
+      await execa('docker-compose', ['version'], { stdio: 'pipe' });
+      return 'docker-compose';
+    } catch {
+      return false;
+    }
+  }
+}
+
+/**
+ * Find docker-compose files in the project
+ */
+export function findDockerComposeFiles(projectPath) {
+  const possibleFiles = [
+    'docker-compose.yml',
+    'docker-compose.yaml',
+    'compose.yml',
+    'compose.yaml',
+    'docker-compose.dev.yml',
+    'docker-compose.dev.yaml',
+    'docker-compose.local.yml',
+    'docker-compose.local.yaml'
+  ];
+  
+  const found = [];
+  for (const file of possibleFiles) {
+    const filePath = path.join(projectPath, file);
+    if (fs.existsSync(filePath)) {
+      found.push({
+        name: file,
+        path: filePath
+      });
+    }
+  }
+  
+  return found;
+}
+
+/**
+ * Check if project has Docker configuration
+ */
+export function hasDockerConfiguration(projectPath) {
+  const composeFiles = findDockerComposeFiles(projectPath);
+  const dockerfilePath = path.join(projectPath, 'Dockerfile');
+  
+  return {
+    hasCompose: composeFiles.length > 0,
+    hasDockerfile: fs.existsSync(dockerfilePath),
+    composeFiles: composeFiles
+  };
+}
+
+/**
+ * Restart Docker containers
+ */
+export async function restartDockerContainers(options = {}) {
+  const {
+    projectPath = process.cwd(),
+    composeFile = null,
+    serviceName = null,
+    forceRecreate = false,
+    rebuild = false,
+    detach = true
+  } = options;
+
+  console.log('\n🐋 Docker Container Restart');
+  console.log('━'.repeat(50));
+
+  try {
+    // Check if Docker is available
+    const dockerCmd = await isDockerComposeAvailable();
+    if (!dockerCmd) {
+      throw new Error('Docker Compose is not available');
+    }
+
+    // Determine compose file to use
+    let composeFilePath = composeFile;
+    if (!composeFilePath) {
+      const dockerConfig = hasDockerConfiguration(projectPath);
+      if (dockerConfig.hasCompose && dockerConfig.composeFiles.length > 0) {
+        composeFilePath = dockerConfig.composeFiles[0].path;
+      } else {
+        throw new Error('No docker-compose file found');
+      }
+    }
+
+    // Build command arguments
+    const isV2 = dockerCmd === 'docker compose';
+    const baseCmd = isV2 ? ['docker', 'compose'] : ['docker-compose'];
+    const fileArgs = ['-f', composeFilePath];
+
+    // Stop containers
+    console.log('📦 Stopping containers...');
+    const stopArgs = [...fileArgs, 'stop'];
+    if (serviceName) stopArgs.push(serviceName);
+    
+    const stopResult = await execa(baseCmd[0], [...baseCmd.slice(1), ...stopArgs], {
+      cwd: projectPath,
+      stdio: 'inherit'
+    });
+
+    // Optionally rebuild
+    if (rebuild) {
+      console.log('🔨 Rebuilding containers...');
+      const buildArgs = [...fileArgs, 'build'];
+      if (serviceName) buildArgs.push(serviceName);
+      
+      await execa(baseCmd[0], [...baseCmd.slice(1), ...buildArgs], {
+        cwd: projectPath,
+        stdio: 'inherit'
+      });
+    }
+
+    // Start containers
+    console.log('🚀 Starting containers...');
+    const upArgs = [...fileArgs, 'up'];
+    if (forceRecreate) upArgs.push('--force-recreate');
+    if (detach) upArgs.push('-d');
+    if (serviceName) upArgs.push(serviceName);
+
+    await execa(baseCmd[0], [...baseCmd.slice(1), ...upArgs], {
+      cwd: projectPath,
+      stdio: 'inherit'
+    });
+
+    console.log('✅ Docker containers restarted successfully');
+    console.log('━'.repeat(50));
+    return { success: true };
+
+  } catch (error) {
+    console.error('❌ Failed to restart Docker containers:', error.message);
+    console.log('━'.repeat(50));
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Get Docker container status
+ */
+export async function getDockerStatus(projectPath = process.cwd(), composeFile = null) {
+  try {
+    const dockerCmd = await isDockerComposeAvailable();
+    if (!dockerCmd) {
+      return { running: false, services: [] };
+    }
+
+    let composeFilePath = composeFile;
+    if (!composeFilePath) {
+      const dockerConfig = hasDockerConfiguration(projectPath);
+      if (dockerConfig.hasCompose && dockerConfig.composeFiles.length > 0) {
+        composeFilePath = dockerConfig.composeFiles[0].path;
+      } else {
+        return { running: false, services: [] };
+      }
+    }
+
+    const isV2 = dockerCmd === 'docker compose';
+    const baseCmd = isV2 ? ['docker', 'compose'] : ['docker-compose'];
+    const psArgs = ['-f', composeFilePath, 'ps', '--format', 'json'];
+
+    const result = await execa(baseCmd[0], [...baseCmd.slice(1), ...psArgs], {
+      cwd: projectPath,
+      stdio: 'pipe'
+    });
+
+    // Parse the JSON output
+    const services = [];
+    if (result.stdout) {
+      const lines = result.stdout.split('\n').filter(line => line.trim());
+      for (const line of lines) {
+        try {
+          const service = JSON.parse(line);
+          services.push({
+            name: service.Service || service.Name,
+            state: service.State,
+            status: service.Status,
+            ports: service.Ports
+          });
+        } catch {
+          // Skip unparseable lines
+        }
+      }
+    }
+
+    return {
+      running: services.some(s => s.state === 'running'),
+      services: services
+    };
+
+  } catch (error) {
+    return { running: false, services: [], error: error.message };
+  }
+}
+
+/**
+ * Monitor Docker logs
+ */
+export async function tailDockerLogs(options = {}) {
+  const {
+    projectPath = process.cwd(),
+    composeFile = null,
+    serviceName = null,
+    lines = 50,
+    follow = true
+  } = options;
+
+  try {
+    const dockerCmd = await isDockerComposeAvailable();
+    if (!dockerCmd) {
+      throw new Error('Docker Compose is not available');
+    }
+
+    let composeFilePath = composeFile;
+    if (!composeFilePath) {
+      const dockerConfig = hasDockerConfiguration(projectPath);
+      if (dockerConfig.hasCompose && dockerConfig.composeFiles.length > 0) {
+        composeFilePath = dockerConfig.composeFiles[0].path;
+      } else {
+        throw new Error('No docker-compose file found');
+      }
+    }
+
+    const isV2 = dockerCmd === 'docker compose';
+    const baseCmd = isV2 ? ['docker', 'compose'] : ['docker-compose'];
+    const logsArgs = ['-f', composeFilePath, 'logs'];
+    
+    if (lines) logsArgs.push('--tail', lines.toString());
+    if (follow) logsArgs.push('-f');
+    if (serviceName) logsArgs.push(serviceName);
+
+    const proc = execa(baseCmd[0], [...baseCmd.slice(1), ...logsArgs], {
+      cwd: projectPath,
+      stdio: 'inherit'
+    });
+
+    return proc;
+
+  } catch (error) {
+    console.error('Failed to tail Docker logs:', error.message);
+    return null;
+  }
+}
+
+export default {
+  isDockerAvailable,
+  isDockerComposeAvailable,
+  findDockerComposeFiles,
+  hasDockerConfiguration,
+  restartDockerContainers,
+  getDockerStatus,
+  tailDockerLogs
+};

package/src/session-coordinator.js

@@ -19,11 +19,12 @@
 
 import fs from 'fs';
 import path from 'path';
-import { execSync, spawn, fork } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import { execSync, spawn, fork } from 'child_process';
 import crypto from 'crypto';
 import readline from 'readline';
+import { hasDockerConfiguration } from './docker-utils.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -367,7 +368,91 @@ class SessionCoordinator {
   }
   
   /**
-   * Prompt for merge configuration
+   * Prompt for Docker restart configuration
+   */
+  async promptForDockerConfig() {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    // Ask if they want automatic Docker restarts
+    const autoRestart = await new Promise((resolve) => {
+      rl.question('\nAuto-restart Docker containers after push? (y/N): ', (answer) => {
+        resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+      });
+    });
+    
+    if (!autoRestart) {
+      rl.close();
+      return { enabled: false };
+    }
+    
+    // Ask which compose file to use if multiple
+    const dockerInfo = hasDockerConfiguration(process.cwd());
+    let selectedComposeFile = null;
+    
+    if (dockerInfo.composeFiles.length > 1) {
+      console.log(`\n${CONFIG.colors.bright}Select docker-compose file:${CONFIG.colors.reset}`);
+      dockerInfo.composeFiles.forEach((file, index) => {
+        console.log(`  ${index + 1}) ${file.name}`);
+      });
+      
+      const fileChoice = await new Promise((resolve) => {
+        rl.question(`Choose file (1-${dockerInfo.composeFiles.length}) [1]: `, (answer) => {
+          const choice = parseInt(answer) || 1;
+          if (choice >= 1 && choice <= dockerInfo.composeFiles.length) {
+            resolve(dockerInfo.composeFiles[choice - 1]);
+          } else {
+            resolve(dockerInfo.composeFiles[0]);
+          }
+        });
+      });
+      
+      selectedComposeFile = fileChoice.path;
+    } else if (dockerInfo.composeFiles.length === 1) {
+      selectedComposeFile = dockerInfo.composeFiles[0].path;
+    }
+    
+    // Ask about rebuild preference
+    const rebuild = await new Promise((resolve) => {
+      rl.question('\nRebuild containers on restart? (y/N): ', (answer) => {
+        resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+      });
+    });
+    
+    // Ask about specific service
+    const specificService = await new Promise((resolve) => {
+      rl.question('\nSpecific service to restart (leave empty for all): ', (answer) => {
+        resolve(answer.trim() || null);
+      });
+    });
+    
+    rl.close();
+    
+    const config = {
+      enabled: true,
+      composeFile: selectedComposeFile,
+      rebuild: rebuild,
+      service: specificService,
+      forceRecreate: false
+    };
+    
+    console.log(`\n${CONFIG.colors.green}✓${CONFIG.colors.reset} Docker restart configuration:`);
+    console.log(`  ${CONFIG.colors.bright}Auto-restart:${CONFIG.colors.reset} Enabled`);
+    if (selectedComposeFile) {
+      console.log(`  ${CONFIG.colors.bright}Compose file:${CONFIG.colors.reset} ${path.basename(selectedComposeFile)}`);
+    }
+    console.log(`  ${CONFIG.colors.bright}Rebuild:${CONFIG.colors.reset} ${rebuild ? 'Yes' : 'No'}`);
+    if (specificService) {
+      console.log(`  ${CONFIG.colors.bright}Service:${CONFIG.colors.reset} ${specificService}`);
+    }
+    
+    return config;
+  }
+
+  /**
+   * Prompt for auto-merge configuration
    */
   async promptForMergeConfig() {
     const rl = readline.createInterface({
@@ -593,6 +678,27 @@ class SessionCoordinator {
     // Ask for auto-merge configuration
     const mergeConfig = await this.promptForMergeConfig();
     
+    // Check for Docker configuration and ask about restart preference
+    let dockerConfig = null;
+    const dockerInfo = hasDockerConfiguration(process.cwd());
+    
+    if (dockerInfo.hasCompose || dockerInfo.hasDockerfile) {
+      console.log(`\n${CONFIG.colors.yellow}Docker Configuration Detected${CONFIG.colors.reset}`);
+      
+      if (dockerInfo.hasCompose) {
+        console.log(`${CONFIG.colors.dim}Found docker-compose files:${CONFIG.colors.reset}`);
+        dockerInfo.composeFiles.forEach(file => {
+          console.log(`  • ${file.name}`);
+        });
+      }
+      
+      if (dockerInfo.hasDockerfile) {
+        console.log(`${CONFIG.colors.dim}Found Dockerfile${CONFIG.colors.reset}`);
+      }
+      
+      dockerConfig = await this.promptForDockerConfig();
+    }
+    
     // Create worktree with developer initials in the name
     const worktreeName = `${agentType}-${devInitials}-${sessionId}-${task.replace(/\s+/g, '-')}`;
     const worktreePath = path.join(this.worktreesPath, worktreeName);
@@ -615,7 +721,8 @@ class SessionCoordinator {
         status: 'active',
         pid: process.pid,
         developerInitials: devInitials,
-        mergeConfig: mergeConfig
+        mergeConfig: mergeConfig,
+        dockerConfig: dockerConfig
       };
       
       const lockFile = path.join(this.locksPath, `${sessionId}.lock`);
@@ -629,7 +736,7 @@ class SessionCoordinator {
       fs.writeFileSync(instructionsFile, instructions.markdown);
       
       // Display instructions
-      this.displayInstructions(instructions, sessionId, task, agentType);
+      this.displayInstructions(instructions, sessionId, task);
       
       // Create session config in worktree
       this.createWorktreeConfig(worktreePath, lockData);
@@ -650,7 +757,7 @@ class SessionCoordinator {
   }
 
   /**
-   * Generate instructions for the specified AI development agent
+   * Generate instructions for Claude/Cline
    */
   generateClaudeInstructions(sessionData) {
     const { sessionId, worktreePath, branchName, task } = sessionData;
@@ -677,7 +784,7 @@ INSTRUCTIONS:
 - **Worktree Path:** \`${worktreePath}\`
 - **Branch:** \`${branchName}\`
 
-## Instructions for ${sessionData.agentType.charAt(0).toUpperCase() + sessionData.agentType.slice(1)}
+## Instructions for Claude/Cline
 
 ### Step 1: Navigate to Your Worktree
 \`\`\`bash
@@ -731,13 +838,12 @@ The DevOps agent will automatically:
   /**
    * Display instructions in a user-friendly format
    */
-  displayInstructions(instructions, sessionId, task, agentType = 'your AI agent') {
-    const agentName = agentType.charAt(0).toUpperCase() + agentType.slice(1);
-    console.log(`\n${CONFIG.colors.bgGreen}${CONFIG.colors.bright} Instructions for ${agentName} ${CONFIG.colors.reset}\n`);
+  displayInstructions(instructions, sessionId, task) {
+    console.log(`\n${CONFIG.colors.bgGreen}${CONFIG.colors.bright} Instructions for Claude/Cline ${CONFIG.colors.reset}\n`);
     
     // Clean separator
     console.log(`${CONFIG.colors.yellow}══════════════════════════════════════════════════════════════${CONFIG.colors.reset}`);
-    console.log(`${CONFIG.colors.bright}COPY AND PASTE THIS ENTIRE BLOCK INTO ${agentName.toUpperCase()} BEFORE YOUR PROMPT:${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.bright}COPY AND PASTE THIS ENTIRE BLOCK INTO CLAUDE BEFORE YOUR PROMPT:${CONFIG.colors.reset}`);
     console.log(`${CONFIG.colors.yellow}──────────────────────────────────────────────────────────────${CONFIG.colors.reset}`);
     console.log();
     
@@ -1079,6 +1185,215 @@ The DevOps agent is monitoring this worktree for changes.
     
     return session;
   }
+  
+  /**
+   * Close a specific session
+   */
+  async closeSession(sessionId) {
+    const lockFile = path.join(this.locksPath, `${sessionId}.lock`);
+    
+    if (!fs.existsSync(lockFile)) {
+      console.error(`${CONFIG.colors.red}Session not found: ${sessionId}${CONFIG.colors.reset}`);
+      return false;
+    }
+    
+    const session = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
+    console.log(`\n${CONFIG.colors.yellow}Closing session: ${sessionId}${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}Task: ${session.task}${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}Branch: ${session.branchName}${CONFIG.colors.reset}`);
+    
+    // Kill agent if running
+    if (session.agentPid) {
+      try {
+        process.kill(session.agentPid, 'SIGTERM');
+        console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Agent process stopped`);
+      } catch (err) {
+        // Process might already be dead
+      }
+    }
+    
+    // Check for uncommitted changes
+    if (fs.existsSync(session.worktreePath)) {
+      try {
+        const status = execSync(`git -C "${session.worktreePath}" status --porcelain`, { encoding: 'utf8' });
+        if (status.trim()) {
+          console.log(`\n${CONFIG.colors.yellow}Warning: Uncommitted changes found${CONFIG.colors.reset}`);
+          console.log(status);
+          
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+          });
+          
+          const answer = await new Promise(resolve => {
+            rl.question('Commit these changes before closing? (y/N): ', resolve);
+          });
+          rl.close();
+          
+          if (answer.toLowerCase() === 'y') {
+            execSync(`git -C "${session.worktreePath}" add -A`, { stdio: 'pipe' });
+            execSync(`git -C "${session.worktreePath}" commit -m "chore: final session cleanup for ${sessionId}"`, { stdio: 'pipe' });
+            execSync(`git -C "${session.worktreePath}" push origin ${session.branchName}`, { stdio: 'pipe' });
+            console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Changes committed and pushed`);
+          }
+        }
+      } catch (err) {
+        console.log(`${CONFIG.colors.dim}Could not check git status${CONFIG.colors.reset}`);
+      }
+      
+      // Ask about removing worktree
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      
+      const removeWorktree = await new Promise(resolve => {
+        rl.question(`\nRemove worktree at ${session.worktreePath}? (Y/n): `, resolve);
+      });
+      rl.close();
+      
+      if (removeWorktree.toLowerCase() !== 'n') {
+        try {
+          // Remove worktree
+          execSync(`git worktree remove "${session.worktreePath}" --force`, { stdio: 'pipe' });
+          console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Worktree removed`);
+          
+          // Prune worktree list
+          execSync('git worktree prune', { stdio: 'pipe' });
+        } catch (err) {
+          console.error(`${CONFIG.colors.red}Failed to remove worktree: ${err.message}${CONFIG.colors.reset}`);
+        }
+      }
+    }
+    
+    // Remove lock file
+    fs.unlinkSync(lockFile);
+    console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Session closed successfully`);
+    
+    return true;
+  }
+  
+  /**
+   * Interactive session selection and close
+   */
+  async selectAndCloseSession() {
+    if (!fs.existsSync(this.locksPath)) {
+      console.log(`${CONFIG.colors.yellow}No active sessions${CONFIG.colors.reset}`);
+      return;
+    }
+    
+    const locks = fs.readdirSync(this.locksPath);
+    if (locks.length === 0) {
+      console.log(`${CONFIG.colors.yellow}No active sessions${CONFIG.colors.reset}`);
+      return;
+    }
+    
+    const sessions = [];
+    locks.forEach(lockFile => {
+      const lockPath = path.join(this.locksPath, lockFile);
+      const session = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+      sessions.push(session);
+    });
+    
+    console.log(`\n${CONFIG.colors.bright}Select session to close:${CONFIG.colors.reset}\n`);
+    
+    sessions.forEach((session, index) => {
+      const status = session.status === 'active' ? 
+        `${CONFIG.colors.green}●${CONFIG.colors.reset}` : 
+        `${CONFIG.colors.yellow}○${CONFIG.colors.reset}`;
+      
+      console.log(`${status} ${CONFIG.colors.bright}${index + 1})${CONFIG.colors.reset} ${session.sessionId}`);
+      console.log(`   Task: ${session.task}`);
+      console.log(`   Branch: ${session.branchName}`);
+      console.log(`   Created: ${session.created}`);
+      console.log();
+    });
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    const answer = await new Promise(resolve => {
+      rl.question(`Select session (1-${sessions.length}) or 'q' to quit: `, resolve);
+    });
+    rl.close();
+    
+    if (answer.toLowerCase() === 'q') {
+      return;
+    }
+    
+    const index = parseInt(answer) - 1;
+    if (index >= 0 && index < sessions.length) {
+      await this.closeSession(sessions[index].sessionId);
+    } else {
+      console.log(`${CONFIG.colors.red}Invalid selection${CONFIG.colors.reset}`);
+    }
+  }
+  
+  /**
+   * Clean up all stale sessions and worktrees
+   */
+  async cleanupAll() {
+    console.log(`\n${CONFIG.colors.yellow}Cleaning up stale sessions and worktrees...${CONFIG.colors.reset}`);
+    
+    // Clean up old lock files (older than 24 hours)
+    const oneDayAgo = Date.now() - 86400000;
+    let cleanedLocks = 0;
+    
+    if (fs.existsSync(this.locksPath)) {
+      const locks = fs.readdirSync(this.locksPath);
+      locks.forEach(lockFile => {
+        const lockPath = path.join(this.locksPath, lockFile);
+        const stats = fs.statSync(lockPath);
+        if (stats.mtimeMs < oneDayAgo) {
+          fs.unlinkSync(lockPath);
+          cleanedLocks++;
+        }
+      });
+    }
+    
+    if (cleanedLocks > 0) {
+      console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Removed ${cleanedLocks} stale lock files`);
+    }
+    
+    // Prune git worktrees
+    try {
+      execSync('git worktree prune', { stdio: 'pipe' });
+      console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Pruned git worktrees`);
+    } catch (err) {
+      console.log(`${CONFIG.colors.dim}Could not prune worktrees${CONFIG.colors.reset}`);
+    }
+    
+    // Clean up orphaned worktree directories
+    if (fs.existsSync(this.worktreesPath)) {
+      const worktrees = fs.readdirSync(this.worktreesPath);
+      let cleanedWorktrees = 0;
+      
+      for (const dir of worktrees) {
+        const worktreePath = path.join(this.worktreesPath, dir);
+        
+        // Check if this worktree is still valid
+        try {
+          execSync(`git worktree list | grep "${worktreePath}"`, { stdio: 'pipe' });
+        } catch (err) {
+          // Worktree not in git list, it's orphaned
+          try {
+            fs.rmSync(worktreePath, { recursive: true, force: true });
+            cleanedWorktrees++;
+          } catch (err) {
+            console.log(`${CONFIG.colors.dim}Could not remove ${dir}${CONFIG.colors.reset}`);
+          }
+        }
+      }
+      
+      if (cleanedWorktrees > 0) {
+        console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Removed ${cleanedWorktrees} orphaned worktree directories`);
+      }
+    }
+    
+    console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Cleanup complete`);
+  }
 }
 
 // ============================================================================
@@ -1154,13 +1469,31 @@ async function main() {
       break;
     }
     
-    case 'list': {
-      coordinator.listSessions();
-      break;
+  case 'list': {
+    coordinator.listSessions();
+    break;
+  }
+  
+  case 'close': {
+    // Close a session and clean up
+    const sessionId = args[1];
+    if (sessionId) {
+      await coordinator.closeSession(sessionId);
+    } else {
+      // Interactive selection
+      await coordinator.selectAndCloseSession();
     }
-    
-    case 'help':
-    default: {
+    break;
+  }
+  
+  case 'cleanup': {
+    // Clean up stale sessions and worktrees
+    await coordinator.cleanupAll();
+    break;
+  }
+  
+  case 'help':
+  default: {
       console.log(`
 ${CONFIG.colors.bright}DevOps Session Coordinator${CONFIG.colors.reset}
 
@@ -1173,6 +1506,8 @@ ${CONFIG.colors.blue}Commands:${CONFIG.colors.reset}
   ${CONFIG.colors.green}create-and-start${CONFIG.colors.reset}    Create session and start agent (all-in-one)
   ${CONFIG.colors.green}request [agent]${CONFIG.colors.reset}     Request a session (for Claude to call)
   ${CONFIG.colors.green}list${CONFIG.colors.reset}                List all active sessions
+  ${CONFIG.colors.green}close [id]${CONFIG.colors.reset}          Close session and clean up worktree
+  ${CONFIG.colors.green}cleanup${CONFIG.colors.reset}             Clean up all stale sessions
   ${CONFIG.colors.green}help${CONFIG.colors.reset}                Show this help
 
 ${CONFIG.colors.blue}Options:${CONFIG.colors.reset}
@@ -1193,9 +1528,9 @@ ${CONFIG.colors.blue}Examples:${CONFIG.colors.reset}
 
 ${CONFIG.colors.yellow}Typical Workflow:${CONFIG.colors.reset}
 1. Run: ${CONFIG.colors.green}node session-coordinator.js create-and-start${CONFIG.colors.reset}
-2. Copy the displayed instructions to your AI development agent (Claude, Cursor, Cline, etc.)
-3. The AI agent navigates to the worktree and starts working
-4. DevOps agent automatically commits and pushes changes
+2. Copy the displayed instructions to Claude/Cline
+3. Claude navigates to the worktree and starts working
+4. Agent automatically commits and pushes changes
 `);
     }
   }

package/start-devops-session.sh

@@ -7,7 +7,7 @@
 # This script provides a user-friendly way to start DevOps agent sessions.
 # It handles the complete workflow:
 # 1. Ask if using existing session or creating new
-# 2. If new, creates session and generates instructions for the AI development agent
+# 2. If new, creates session and generates instructions for Claude
 # 3. Starts the DevOps agent monitoring the appropriate worktree
 #
 # ============================================================================
@@ -62,13 +62,12 @@ display_instructions() {
     local worktree_path="$2"
     local branch_name="$3"
     local task="$4"
-    local agent_type="${5:-AI Development Agent}"
     
     echo
-    echo -e "${BG_GREEN}${BOLD} Instructions for ${agent_type} ${NC}"
+    echo -e "${BG_GREEN}${BOLD} Instructions for Claude/Cline ${NC}"
     echo
     echo -e "${YELLOW}══════════════════════════════════════════════════════════════${NC}"
-    echo -e "${BOLD}COPY AND PASTE THIS ENTIRE BLOCK INTO YOUR AI AGENT BEFORE YOUR PROMPT:${NC}"
+    echo -e "${BOLD}COPY AND PASTE THIS ENTIRE BLOCK INTO CLAUDE BEFORE YOUR PROMPT:${NC}"
     echo -e "${YELLOW}──────────────────────────────────────────────────────────────${NC}"
     echo
     echo "I'm working in a DevOps-managed session with the following setup:"
@@ -216,12 +215,8 @@ select_session() {
         echo
         echo -e "${GREEN}Using existing session: ${session_id}${NC}"
         
-        # Extract agent type from session data
-        local agent_type=$(echo "$session_data" | grep -o '"agentType"[[:space:]]*:[[:space:]]*"[^"]*"' | sed 's/.*: *"\([^"]*\)".*/\1/')
-        [[ -z "$agent_type" ]] && agent_type="AI Agent"
-        
-        # Display instructions for the AI agent IMMEDIATELY after selection
-        display_instructions "$session_id" "$worktree_path" "$branch_name" "$task" "$agent_type"
+        # Display instructions for Claude/Cline IMMEDIATELY after selection
+        display_instructions "$session_id" "$worktree_path" "$branch_name" "$task"
         
         # Add a pause and visual separator before starting the agent
         echo -e "${DIM}Press Enter to start the DevOps agent monitoring...${NC}"
@@ -265,7 +260,7 @@ main() {
     echo
     echo "This tool will:"
     echo "  1. Help you create or select a session"
-    echo "  2. Generate instructions for your AI development agent"
+    echo "  2. Generate instructions for Claude/Cline"
     echo "  3. Start the DevOps agent to monitor changes"
     echo