s9n-devops-agent 1.3.4 → 1.4.0

package/docs/houserules.md

@@ -53,21 +53,43 @@ To prevent conflicts with other agents editing the same files, you MUST follow t
 
 ## Testing Policy (Required)
 
+### Test-Driven Development (TDD) Requirements
+
+**CRITICAL: For ALL new features and copied code (except infrastructure):**
+1. **WRITE THE TEST FIRST** - Before implementing any new functionality
+2. **RED-GREEN-REFACTOR** cycle:
+   - RED: Write a failing test that defines expected behavior
+   - GREEN: Write minimal code to make the test pass
+   - REFACTOR: Improve the code while keeping tests green
+
+### When Tests Are MANDATORY:
+- **New Features**: Test MUST be written BEFORE implementation code
+- **Copied/Adapted Code**: Test MUST verify the adaptation works correctly
+- **Bug Fixes**: Test MUST reproduce the bug first (fail), then pass after fix
+- **API Changes**: Test MUST cover new endpoints/methods
+- **Business Logic**: Test MUST validate all logic paths
+
+### When Tests Are OPTIONAL:
+- **Pure Infrastructure Code**: Build scripts, deployment configs
+- **Configuration Files**: Unless they contain logic
+- **Documentation**: README files, comments
+- **Generated Code**: Auto-generated files (but test the generator!)
+
 Goal: Every bug fix and feature ships with an executable test.
 
 Location: test_cases/<area>/<component>/.
 
-DoD: (1) failing test reproduces bug (red), (2) fix makes it pass (green), (3) tests wired into CI and local runner.
+DoD: (1) failing test defines behavior (red), (2) implementation makes it pass (green), (3) tests wired into CI and local runner.
 
 Naming: YYYYMMDD_<short-slug>_spec.(py|ts|js|go|rb|java)
 
-Non-duplication: Extend existing tests for the same bug.
+Non-duplication: Extend existing tests for the same functionality.
 
 Determinism: No flaky/random tests; use seeds and fake timers.
 
 ## Test Generation Rules (for Claude / code assistants)
 
-Always write the failing test first.
+**ALWAYS write the test BEFORE the implementation code.**
 
 Infer <area>/<component> from changed paths.
 
@@ -77,6 +99,47 @@ Use native runners per language (pytest, vitest/jest, go test, rspec, JUnit).
 
 Add short "why it failed before the fix" note in the test.
 
+## TDD Workflow for New Features
+
+### Step 1: Write the Test First
+Before writing ANY implementation code:
+1. Create test file in `test_cases/<area>/<component>/`
+2. Define expected behavior through test assertions
+3. Run test to ensure it FAILS (Red phase)
+4. Commit the failing test with message: `test: add failing test for <feature>`
+
+### Step 2: Implement Minimal Code
+1. Write ONLY enough code to make the test pass
+2. Don't add extra features or optimizations yet
+3. Run test to ensure it PASSES (Green phase)
+4. Commit implementation with message: `feat: implement <feature> to pass test`
+
+### Step 3: Refactor (if needed)
+1. Improve code quality, performance, or structure
+2. Ensure tests still pass after each change
+3. Commit refactoring with message: `refactor: improve <aspect> of <feature>`
+
+### Example TDD Flow for Agents:
+```bash
+# 1. First, declare your intent to edit test and implementation files
+echo '{"files": ["test_cases/session/coordinator/test_new_feature.js", "src/new_feature.js"]}' > .file-coordination/active-edits/claude-session.json
+
+# 2. Write the test FIRST
+# Create: test_cases/session/coordinator/20241003_new_feature_spec.js
+
+# 3. Run test to verify it fails
+npm test test_cases/session/coordinator/20241003_new_feature_spec.js
+
+# 4. NOW write the implementation
+# Create/modify: src/new_feature.js
+
+# 5. Run test to verify it passes
+npm test test_cases/session/coordinator/20241003_new_feature_spec.js
+
+# 6. Release your file locks
+rm .file-coordination/active-edits/claude-session.json
+```
+
 ## Test Case Template
 ```
 # Test Case: <human title>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s9n-devops-agent",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "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

@@ -1454,7 +1454,31 @@ console.log();
     ignoreInitial: true,
     usePolling: USE_POLLING,
     interval: 500,
-    ignored: ["**/__pycache__/**", "**/*.pyc", "**/.DS_Store", "**/logs/**"],
+    ignored: [
+      "**/__pycache__/**",
+      "**/*.pyc",
+      "**/.DS_Store",
+      "**/logs/**",
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/local_deploy/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/coverage/**",
+      "**/.next/**",
+      "**/.nuxt/**",
+      "**/tmp/**",
+      "**/temp/**",
+      "**/.cache/**",
+      "**/vendor/**",
+      "**/.vscode/**",
+      "**/.idea/**",
+      "**/*.log",
+      "**/*.lock",
+      "**/package-lock.json",
+      "**/yarn.lock",
+      "**/pnpm-lock.yaml"
+    ],
   })
   .on("all", async (evt, p) => {
     const now = Date.now();

package/src/docker-utils.js

@@ -46,7 +46,7 @@ export async function isDockerComposeAvailable() {
 }
 
 /**
- * Find docker-compose files in the project
+ * Find docker-compose files in the project, parent directory, and parent/Infrastructure
  */
 export function findDockerComposeFiles(projectPath) {
   const possibleFiles = [
@@ -60,14 +60,30 @@ export function findDockerComposeFiles(projectPath) {
     'docker-compose.local.yaml'
   ];
   
+  const searchLocations = [
+    { path: projectPath, label: 'project directory' },
+    { path: path.dirname(projectPath), label: 'parent directory' },
+    { path: path.join(path.dirname(projectPath), 'Infrastructure'), label: 'parent/Infrastructure' },
+    { path: path.join(path.dirname(projectPath), 'infrastructure'), label: 'parent/infrastructure' }
+  ];
+  
   const found = [];
-  for (const file of possibleFiles) {
-    const filePath = path.join(projectPath, file);
-    if (fs.existsSync(filePath)) {
-      found.push({
-        name: file,
-        path: filePath
-      });
+  
+  for (const location of searchLocations) {
+    // Check if location exists
+    if (!fs.existsSync(location.path)) {
+      continue;
+    }
+    
+    for (const file of possibleFiles) {
+      const filePath = path.join(location.path, file);
+      if (fs.existsSync(filePath)) {
+        found.push({
+          name: file,
+          path: filePath,
+          location: location.label
+        });
+      }
     }
   }
   

package/src/house-rules-manager.js

@@ -529,6 +529,228 @@ ${endMarker}`;
     }
   }
 
+  /**
+   * Initial setup - prompt for folder structure preference and copy appropriate files
+   */
+  async initialSetup() {
+    // Check if house rules already exist
+    if (this.houseRulesPath && fs.existsSync(this.houseRulesPath)) {
+      return {
+        alreadyExists: true,
+        path: this.houseRulesPath,
+        message: 'House rules already exist'
+      };
+    }
+
+    // Import readline for interactive prompts
+    const readline = await import('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+      console.log('\n📋 House Rules Setup');
+      console.log('━'.repeat(60));
+      console.log('\nWould you like to enforce a structured folder organization?');
+      console.log('\n  ✅ YES - Get comprehensive folder structure with guidelines');
+      console.log('     • Modular organization (/ModuleName/src/featurename/)');
+      console.log('     • Best for: New projects, large applications');
+      console.log('     • Includes: houserules + folders.md guide');
+      console.log('\n  ❌ NO  - Use flexible structure (organize your own way)');
+      console.log('     • No enforced folder structure');
+      console.log('     • Best for: Existing projects, quick setup');
+      console.log('     • Includes: Core house rules only');
+      console.log();
+      
+      rl.question('Do you want structured folder organization? (Y/N) [N]: ', (answer) => {
+        const wantStructure = answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes';
+        rl.close();
+        
+        try {
+          const result = this.setupHouseRules(wantStructure);
+          console.log();
+          console.log(`${wantStructure ? '📁' : '📄'} House rules setup complete!`);
+          console.log(`   Location: ${result.houseRulesPath}`);
+          
+          if (wantStructure) {
+            console.log(`   Folder guide: ${result.foldersPath}`);
+            console.log();
+            console.log('💡 TIP: Open folders.md to customize your project structure');
+          }
+          
+          if (result.infrastructurePath) {
+            console.log(`   Infrastructure docs: ${result.infrastructurePath}`);
+          }
+          
+          console.log();
+          resolve(result);
+        } catch (error) {
+          console.error('❌ Failed to setup house rules:', error.message);
+          resolve({ success: false, error: error.message });
+        }
+      });
+    });
+  }
+
+  /**
+   * Setup house rules by copying appropriate template
+   */
+  setupHouseRules(withStructure = false) {
+    // Determine source and target paths
+    const agentRoot = path.join(__dirname, '..');
+    const sourceFileName = withStructure ? 'houserules_structured.md' : 'houserules_core.md';
+    const sourcePath = path.join(agentRoot, sourceFileName);
+    const targetPath = path.join(this.projectRoot, 'houserules.md');
+    
+    // Verify source file exists
+    if (!fs.existsSync(sourcePath)) {
+      throw new Error(`Source house rules template not found: ${sourcePath}`);
+    }
+    
+    // Copy house rules
+    fs.copyFileSync(sourcePath, targetPath);
+    this.houseRulesPath = targetPath;
+    
+    const result = {
+      success: true,
+      withStructure,
+      houseRulesPath: targetPath
+    };
+    
+    // If structured, also copy folders.md
+    if (withStructure) {
+      const foldersSrc = path.join(agentRoot, 'folders.md');
+      const foldersDest = path.join(this.projectRoot, 'folders.md');
+      
+      if (fs.existsSync(foldersSrc)) {
+        fs.copyFileSync(foldersSrc, foldersDest);
+        result.foldersPath = foldersDest;
+      }
+    }
+    
+    // Always create infrastructure directory and template
+    const infraDir = path.join(this.projectRoot, 'infrastructure');
+    if (!fs.existsSync(infraDir)) {
+      fs.mkdirSync(infraDir, { recursive: true });
+    }
+    
+    const infraDocPath = path.join(infraDir, 'infrastructure.md');
+    if (!fs.existsSync(infraDocPath)) {
+      const infraTemplate = this.getInfrastructureTemplate();
+      fs.writeFileSync(infraDocPath, infraTemplate);
+      result.infrastructurePath = infraDocPath;
+    }
+    
+    return result;
+  }
+
+  /**
+   * Get infrastructure.md template content
+   */
+  getInfrastructureTemplate() {
+    return `# Infrastructure Documentation
+
+**IMPORTANT**: This file documents all infrastructure resources for this project.
+Always read this file before creating new servers, instances, or Docker containers.
+
+## Overview
+Last Updated: ${new Date().toISOString()}
+
+## Docker Containers
+
+### Example Container
+- **Name**: example-service
+- **Image**: nginx:latest
+- **Ports**: 8080:80
+- **Purpose**: Example web server
+- **Dependencies**: None
+- **Configuration**: 
+  - Environment: \`ENV=production\`
+  - Volumes: \`./data:/usr/share/nginx/html\`
+
+## Servers / Instances
+
+### Example Server
+- **Name**: api-server
+- **Type**: AWS EC2 t2.micro
+- **IP/Domain**: api.example.com
+- **Purpose**: REST API backend
+- **Access**: SSH key required
+- **Dependencies**: PostgreSQL database
+
+## Databases
+
+### Example Database
+- **Name**: main-db
+- **Type**: PostgreSQL 14
+- **Host**: localhost:5432
+- **Purpose**: Application data storage
+- **Backup Schedule**: Daily at 2 AM UTC
+
+## Services / APIs
+
+### Example Service
+- **Name**: auth-service
+- **Type**: OAuth2 Provider
+- **Endpoint**: https://auth.example.com
+- **Purpose**: User authentication
+- **API Keys**: Stored in environment variables
+
+## Network Configuration
+
+- **VPC/Network**: default
+- **Subnets**: 
+  - Public: 10.0.1.0/24
+  - Private: 10.0.2.0/24
+- **Security Groups**: 
+  - web-sg: Allows 80, 443
+  - api-sg: Allows 8080
+
+## Monitoring & Logging
+
+- **Monitoring**: CloudWatch / Prometheus
+- **Logging**: Centralized logging to /var/log/
+- **Alerts**: Email notifications enabled
+
+## Backup & Recovery
+
+- **Backup Location**: S3 bucket or local path
+- **Recovery Time Objective (RTO)**: < 1 hour
+- **Recovery Point Objective (RPO)**: < 15 minutes
+
+## Access & Credentials
+
+**NOTE**: Never commit credentials to this file.
+Document where credentials are stored (e.g., password manager, secrets vault).
+
+- **SSH Keys**: Stored in team password manager
+- **API Keys**: Environment variables only
+- **Database Passwords**: AWS Secrets Manager
+
+## Rollback Procedures
+
+### How to Remove/Rollback Infrastructure
+
+1. **Docker Containers**: 
+   \`\`\`bash
+   docker-compose down
+   \`\`\`
+
+2. **Servers**: 
+   - Stop the instance via cloud console
+   - Take snapshot before termination
+   - Document instance ID and configuration
+
+## Change History
+
+### YYYY-MM-DD - Initial Setup
+- Created base infrastructure
+- Deployed example services
+- Configured networking and security
+`;
+  }
+
   /**
    * Get status of house rules
    */

package/src/session-coordinator.js

@@ -25,6 +25,7 @@ import { execSync, spawn, fork } from 'child_process';
 import crypto from 'crypto';
 import readline from 'readline';
 import { hasDockerConfiguration } from './docker-utils.js';
+import HouseRulesManager from './house-rules-manager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -150,6 +151,19 @@ class SessionCoordinator {
     }
   }
   
+  /**
+   * Ensure house rules are set up for the project
+   */
+  async ensureHouseRulesSetup() {
+    const houseRulesManager = new HouseRulesManager(this.repoRoot);
+    
+    // Check if house rules exist
+    if (!houseRulesManager.houseRulesPath || !fs.existsSync(houseRulesManager.houseRulesPath)) {
+      console.log(`\n${CONFIG.colors.yellow}House rules not found - setting up now...${CONFIG.colors.reset}`);
+      await houseRulesManager.initialSetup();
+    }
+  }
+  
   /**
    * Ensure project-specific version settings are configured
    */
@@ -463,6 +477,16 @@ class SessionCoordinator {
    * Prompt for auto-merge configuration
    */
   async promptForMergeConfig() {
+    // Check if auto-merge setting is already configured
+    const projectSettings = this.loadProjectSettings();
+    if (projectSettings.autoMergeConfig && projectSettings.autoMergeConfig.alwaysEnabled !== undefined) {
+      // Already configured with 'Always', use saved settings
+      if (projectSettings.autoMergeConfig.alwaysEnabled) {
+        console.log(`\n${CONFIG.colors.dim}Using saved auto-merge configuration${CONFIG.colors.reset}`);
+        return projectSettings.autoMergeConfig;
+      }
+    }
+    
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
@@ -476,18 +500,26 @@ class SessionCoordinator {
     console.log(`  • At the end of each day, your work is automatically merged`);
     console.log(`  • This keeps your target branch (main/develop) up to date`);
     console.log(`  • Prevents accumulation of stale feature branches`);
+    console.log();
+    console.log(`${CONFIG.colors.bright}Options:${CONFIG.colors.reset}`);
+    console.log(`  ${CONFIG.colors.green}Y${CONFIG.colors.reset}) Yes - Enable for this session only`);
+    console.log(`  ${CONFIG.colors.red}N${CONFIG.colors.reset}) No - Disable for this session`);
+    console.log(`  ${CONFIG.colors.blue}A${CONFIG.colors.reset}) Always - Enable and remember for all sessions (24x7 operation)`);
     
     // Ask if they want auto-merge
-    const autoMerge = await new Promise((resolve) => {
-      rl.question('\nEnable auto-merge at end of day? (y/N): ', (answer) => {
-        resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    const answer = await new Promise((resolve) => {
+      rl.question('\nEnable auto-merge? (Y/N/A) [N]: ', (ans) => {
+        resolve(ans.trim().toLowerCase());
       });
     });
     
+    const autoMerge = answer === 'y' || answer === 'yes' || answer === 'a' || answer === 'always';
+    const alwaysAutoMerge = answer === 'a' || answer === 'always';
+    
     if (!autoMerge) {
       rl.close();
       console.log(`${CONFIG.colors.dim}Auto-merge disabled. You'll need to manually merge your work.${CONFIG.colors.reset}`);
-      return { autoMerge: false };
+      return { autoMerge: false, alwaysEnabled: false };
     }
     
     // Get available branches
@@ -549,12 +581,23 @@ class SessionCoordinator {
       autoMerge: true,
       targetBranch,
       strategy,
-      requireTests: strategy !== 'pull-request'
+      requireTests: strategy !== 'pull-request',
+      alwaysEnabled: alwaysAutoMerge
     };
     
     console.log(`\n${CONFIG.colors.green}✓${CONFIG.colors.reset} Auto-merge configuration saved:`);
     console.log(`  ${CONFIG.colors.bright}Today's work${CONFIG.colors.reset} → ${CONFIG.colors.bright}${targetBranch}${CONFIG.colors.reset}`);
     console.log(`  Strategy: ${CONFIG.colors.bright}${strategy}${CONFIG.colors.reset}`);
+    
+    if (alwaysAutoMerge) {
+      console.log(`  ${CONFIG.colors.blue}Mode: Always enabled${CONFIG.colors.reset} (24x7 operation - auto rollover)`);
+      // Save to project settings
+      projectSettings.autoMergeConfig = config;
+      this.saveProjectSettings(projectSettings);
+    } else {
+      console.log(`  ${CONFIG.colors.dim}Mode: This session only${CONFIG.colors.reset}`);
+    }
+    
     console.log(`${CONFIG.colors.dim}  (Daily branches will be merged into ${targetBranch} at end of day)${CONFIG.colors.reset}`);
     
     return config;
@@ -677,6 +720,7 @@ class SessionCoordinator {
     // Ensure both global and project setup are complete
     await this.ensureGlobalSetup();     // Developer initials (once per user)
     await this.ensureProjectSetup();    // Version strategy (once per project)
+    await this.ensureHouseRulesSetup(); // House rules setup (once per project)
     
     const sessionId = this.generateSessionId();
     const task = options.task || 'development';
@@ -702,7 +746,7 @@ class SessionCoordinator {
       if (dockerInfo.hasCompose) {
         console.log(`${CONFIG.colors.dim}Found docker-compose files:${CONFIG.colors.reset}`);
         dockerInfo.composeFiles.forEach(file => {
-          console.log(`  • ${file.name}`);
+          console.log(`  • ${file.name} ${CONFIG.colors.dim}(in ${file.location})${CONFIG.colors.reset}`);
         });
       }
       
@@ -711,12 +755,78 @@ class SessionCoordinator {
       }
       
       dockerConfig = await this.promptForDockerConfig();
+    } else {
+      // No Docker configuration found - prompt user
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      
+      console.log(`\n${CONFIG.colors.yellow}No Docker Configuration Found${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}I couldn't find any docker-compose files in:${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • Project directory${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • Parent directory${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • Parent/Infrastructure or parent/infrastructure${CONFIG.colors.reset}`);
+      
+      const hasDocker = await new Promise((resolve) => {
+        rl.question(`\nDo you have a Docker setup you'd like to configure? (y/N): `, (answer) => {
+          resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+      });
+      
+      if (hasDocker) {
+        const dockerPath = await new Promise((resolve) => {
+          rl.question(`\nEnter the full path to your docker-compose file: `, (answer) => {
+            resolve(answer.trim());
+          });
+        });
+        
+        if (dockerPath && fs.existsSync(dockerPath)) {
+          console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Found docker-compose file at: ${dockerPath}`);
+          
+          // Ask about rebuild and service preferences
+          const rebuild = await new Promise((resolve) => {
+            rl.question('\nRebuild containers on restart? (y/N): ', (answer) => {
+              resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+            });
+          });
+          
+          const specificService = await new Promise((resolve) => {
+            rl.question('\nSpecific service to restart (leave empty for all): ', (answer) => {
+              resolve(answer.trim() || null);
+            });
+          });
+          
+          dockerConfig = {
+            enabled: true,
+            composeFile: dockerPath,
+            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`);
+          console.log(`  ${CONFIG.colors.bright}Compose file:${CONFIG.colors.reset} ${path.basename(dockerPath)}`);
+          console.log(`  ${CONFIG.colors.bright}Rebuild:${CONFIG.colors.reset} ${rebuild ? 'Yes' : 'No'}`);
+          if (specificService) {
+            console.log(`  ${CONFIG.colors.bright}Service:${CONFIG.colors.reset} ${specificService}`);
+          }
+        } else if (dockerPath) {
+          console.log(`${CONFIG.colors.red}✗${CONFIG.colors.reset} File not found: ${dockerPath}`);
+          console.log(`${CONFIG.colors.dim}Skipping Docker configuration${CONFIG.colors.reset}`);
+        }
+      } else {
+        console.log(`${CONFIG.colors.dim}Skipping Docker configuration${CONFIG.colors.reset}`);
+      }
+      
+      rl.close();
     }
     
-    // Create worktree with developer initials in the name
-    const worktreeName = `${agentType}-${devInitials}-${sessionId}-${task.replace(/\s+/g, '-')}`;
+    // Create worktree with developer initials first in the name
+    const worktreeName = `${devInitials}-${agentType}-${sessionId}-${task.replace(/\s+/g, '-')}`;
     const worktreePath = path.join(this.worktreesPath, worktreeName);
-    const branchName = `${agentType}/${devInitials}/${sessionId}/${task.replace(/\s+/g, '-')}`;
+    const branchName = `${devInitials}/${agentType}/${sessionId}/${task.replace(/\s+/g, '-')}`;
     
     try {
       // Detect if we're in a submodule and get the parent repository
@@ -970,6 +1080,34 @@ The DevOps agent will automatically:
    * Create configuration in the worktree
    */
   createWorktreeConfig(worktreePath, sessionData) {
+    // Create file coordination directory structure
+    const fileCoordDir = path.join(worktreePath, '.file-coordination');
+    const activeEditsDir = path.join(fileCoordDir, 'active-edits');
+    const historyDir = path.join(fileCoordDir, 'history');
+    
+    // Create directories if they don't exist
+    [fileCoordDir, activeEditsDir, historyDir].forEach(dir => {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    });
+    
+    // Create README for file coordination
+    const coordReadme = `# File Coordination System
+
+This directory manages multi-agent file access coordination.
+
+## Structure
+- \`active-edits/\` - Current file locks by agents
+- \`history/\` - Completed edits log
+
+## Usage
+Agents must declare files before editing by creating a JSON file in active-edits/.
+See house rules for details.
+`;
+    fs.writeFileSync(path.join(fileCoordDir, 'README.md'), coordReadme);
+    console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Created file coordination directory structure`);
+    
     // Session config file
     const configPath = path.join(worktreePath, '.devops-session.json');
     fs.writeFileSync(configPath, JSON.stringify(sessionData, null, 2));
@@ -991,7 +1129,7 @@ The DevOps agent will automatically:
         'DEVOPS_WORKTREE': path.basename(worktreePath),
         'DEVOPS_BRANCH': sessionData.branchName,
         'AC_MSG_FILE': `.devops-commit-${sessionData.sessionId}.msg`,
-        'AC_BRANCH_PREFIX': `${sessionData.agentType}_${sessionData.sessionId}_`
+        'AC_BRANCH_PREFIX': `${sessionData.developerInitials || 'dev'}_${sessionData.agentType}_${sessionData.sessionId}_`
       }
     };
     
@@ -1165,12 +1303,12 @@ The DevOps agent is monitoring this worktree for changes.
       ...process.env,
       DEVOPS_SESSION_ID: sessionId,
       AC_MSG_FILE: `.devops-commit-${sessionId}.msg`,
-      AC_BRANCH_PREFIX: `${sessionData.agentType}_${devInitials}_${sessionId}_`,
+      AC_BRANCH_PREFIX: `${devInitials}_${sessionData.agentType}_${sessionId}_`,
       AC_WORKING_DIR: sessionData.worktreePath,
       // Don't set AC_BRANCH - let the agent create daily branches within the worktree
       // AC_BRANCH would force a static branch, preventing daily/weekly rollover
       AC_PUSH: 'true',  // Enable auto-push for session branches
-      AC_DAILY_PREFIX: `${sessionData.agentType}_${devInitials}_${sessionId}_`,  // Daily branches with dev initials
+      AC_DAILY_PREFIX: `${devInitials}_${sessionData.agentType}_${sessionId}_`,  // Daily branches with dev initials first
       AC_TZ: process.env.AC_TZ || 'Asia/Dubai',  // Preserve timezone for daily branches
       AC_DATE_STYLE: process.env.AC_DATE_STYLE || 'dash',  // Preserve date style
       // Apply version configuration if set