s9n-devops-agent 2.0.18-dev.1 → 2.0.18-dev.12

package/README.md

@@ -81,6 +81,7 @@ s9n-devops-agent start
 ### 🌲 Smart Branch Management
 - **Hierarchy:** `session/task` → `daily/date` → `main`.
 - **Auto-Merge:** Sessions automatically merge into daily branches, which roll over to main.
+- **Base Branch Selection:** Choose any branch (main, develop, etc.) as the starting point for your session worktree.
 
 ### 📋 House Rules System
 - **Context Injection:** AI agents read `docs/houserules.md` to understand your coding conventions.

package/bin/cs-devops-agent

@@ -54,21 +54,11 @@ function runShellScript(scriptPath, scriptArgs = []) {
 switch(command) {
   case 'start':
   case 'session':
-    // Start interactive session manager
-    // On Windows, always use Node.js coordinator (bash may not be available)
-    if (process.platform === 'win32') {
-      console.log('Starting DevOps Agent session manager...\n');
-      runScript(join(rootDir, 'src', 'session-coordinator.js'), ['start', ...args.slice(1)]);
-    } else {
-      // Unix/Mac: use bash script
-      const sessionScript = join(rootDir, 'start-devops-session.sh');
-      if (fs.existsSync(sessionScript)) {
-        runShellScript(sessionScript, args.slice(1));
-      } else {
-        console.error('Session script not found. Please ensure the package is properly installed.');
-        process.exit(1);
-      }
-    }
+  case 'chat':
+    // Unified entry point: Run Kora (Smart Assistant)
+    // Kora handles session creation and management conversationally
+    console.log('Starting Kora (Smart DevOps Assistant)...');
+    runScript(join(rootDir, 'src', 'agent-chat.js'), args.slice(1));
     break;
     
   case 'worker':
@@ -101,6 +91,11 @@ switch(command) {
     runScript(join(rootDir, 'src', 'session-coordinator.js'), ['create', ...args.slice(1)]);
     break;
     
+  case 'resume':
+    // Resume existing session
+    runScript(join(rootDir, 'src', 'session-coordinator.js'), ['resume', ...args.slice(1)]);
+    break;
+    
   case 'close':
     // Close session
     runScript(join(rootDir, 'src', 'close-session.js'), args.slice(1));
@@ -118,7 +113,7 @@ switch(command) {
     break;
     
   case 'chat':
-    // Run the chat agent
+    // Run the chat agent (kept for backward compatibility, now same as start)
     runScript(join(rootDir, 'src', 'agent-chat.js'), args.slice(1));
     break;
 
@@ -207,11 +202,12 @@ For more information, visit: https://github.com/SecondBrainAICo/CS_DevOpsAgent
     break;
 
   default:
-    // Default to chat if no command provided, or if unknown command
-    // This replaces the prior UX where help was default
+    // Default to Kora (Smart Assistant) if no command provided
+    // This provides the unified experience
     if (!command || !command.startsWith('-')) {
-      console.log('Starting Kora Smart Assistant...');
-      runScript(join(rootDir, 'src', 'agent-chat.js'), args.slice(1));
+      console.log('Starting Kora (Smart DevOps Assistant)...');
+      // Pass all args to agent-chat
+      runScript(join(rootDir, 'src', 'agent-chat.js'), args);
     } else {
       // Show help for flags like -h, --help, or unknown flags
       console.log(`\nCS_DevOpsAgent - Intelligent Git Automation System`);

package/docs/RELEASE_NOTES.md

@@ -1,3 +1,18 @@
+# Release Notes - s9n-devops-agent v2.0.18-dev.3
+
+## 🚀 Enhancements
+- **Base Branch Selection**: You can now select a base branch (e.g., main, develop) when starting a session, allowing for cleaner feature branching from stable points.
+- **Enhanced Setup Wizard**: 
+  - Finds and merges contract files from subdirectories.
+  - Ensures versioning strategy is configured.
+  - Persists credentials in user home directory to survive package updates.
+
+## 🐛 Fixes
+- **Update Logic**: Fixed update checker to respect dev versions.
+- **Credentials**: Fixed issue where API keys were lost during updates.
+
+---
+
 # Release Notes - s9n-devops-agent v2.0.11-dev.0
 
 ## 🐛 Fixed

package/package.json

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

package/scripts/deploy-local.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+
+# Deploy DevOpsAgent locally to a target directory
+# Usage: ./scripts/deploy-local.sh <target_directory>
+
+TARGET_DIR="$1"
+
+if [ -z "$TARGET_DIR" ]; then
+  echo "Usage: $0 <target_directory>"
+  exit 1
+fi
+
+if [ ! -d "$TARGET_DIR" ]; then
+  echo "Error: Target directory $TARGET_DIR does not exist"
+  exit 1
+fi
+
+SOURCE_DIR="$(pwd)"
+DEST_DIR="$TARGET_DIR/DevOpsAgent"
+
+echo "Deploying DevOpsAgent to $DEST_DIR..."
+
+# Create destination directory
+mkdir -p "$DEST_DIR"
+
+# Copy files
+echo "Copying files..."
+rsync -av --exclude 'node_modules' \
+          --exclude '.git' \
+          --exclude '.DS_Store' \
+          --exclude 'local_deploy' \
+          --exclude 'coverage' \
+          --exclude 'test_cases' \
+          "$SOURCE_DIR/" "$DEST_DIR/"
+
+# Install dependencies in the target
+echo "Installing dependencies in $DEST_DIR..."
+cd "$DEST_DIR"
+npm install --production --silent
+cd "$SOURCE_DIR"
+
+# Create universal runner script
+RUNNER="$TARGET_DIR/devops"
+LOG_FILE="$TARGET_DIR/devops-agent.log"
+
+echo "Creating 'devops' CLI wrapper..."
+
+cat > "$RUNNER" << EOF
+#!/bin/bash
+
+# DevOps Agent CLI Wrapper
+# Supports all standard commands: start, chat, setup, worker, etc.
+
+DIR="\$(cd "\$(dirname "\$0")" && pwd)"
+AGENT_DIR="\$DIR/DevOpsAgent"
+LOG_FILE="\$DIR/devops-agent.log"
+
+# Ensure executable permissions
+chmod +x "\$AGENT_DIR/bin/cs-devops-agent"
+
+# If first arg is 'worker' or 'background', run in background
+if [ "\$1" == "background" ]; then
+  echo "Starting worker in background..."
+  echo "--- Worker Start: \$(date) ---" >> "\$LOG_FILE"
+  export AC_DEBUG="true"
+  node "\$AGENT_DIR/src/cs-devops-agent-worker.js" >> "\$LOG_FILE" 2>&1 &
+  echo "Worker PID: \$!"
+  echo "Logs: \$LOG_FILE"
+  exit 0
+fi
+
+# Otherwise run interactive CLI
+node "\$AGENT_DIR/bin/cs-devops-agent" "\$@"
+EOF
+
+chmod +x "$RUNNER"
+
+# Add to gitignore in target
+GITIGNORE="$TARGET_DIR/.gitignore"
+if [ -f "$GITIGNORE" ]; then
+  if ! grep -q "DevOpsAgent/" "$GITIGNORE"; then
+    echo "" >> "$GITIGNORE"
+    echo "# DevOps Agent" >> "$GITIGNORE"
+    echo "DevOpsAgent/" >> "$GITIGNORE"
+    echo "devops-agent.log" >> "$GITIGNORE"
+    echo "devops" >> "$GITIGNORE"
+    echo "Added DevOpsAgent files to .gitignore"
+  fi
+fi
+
+echo "Deployment complete!"
+echo "Use the './devops' script to interact with the agent:"
+echo ""
+echo "  ./devops setup        # Run first-time setup"
+echo "  ./devops chat         # Chat with Kora"
+echo "  ./devops start        # Start session manager (Interactive)"
+echo "  ./devops background   # Run worker silently"
+echo "  ./devops --help       # See all commands"
+echo ""
+echo "Logs location: '$LOG_FILE'"

package/src/agent-chat.js

@@ -23,7 +23,7 @@ import readline from 'readline';
 import Groq from 'groq-sdk';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import { credentialsManager } from './credentials-manager.js';
 import HouseRulesManager from './house-rules-manager.js';
 // We'll import SessionCoordinator dynamically to avoid circular deps if any
@@ -51,9 +51,14 @@ const CONFIG = {
 
 class SmartAssistant {
   constructor() {
-    this.groq = new Groq({
-      apiKey: process.env.GROQ_API_KEY || process.env.OPENAI_API_KEY
-    });
+    // Initialize Groq client lazily or with null if key is missing
+    const apiKey = process.env.GROQ_API_KEY || process.env.OPENAI_API_KEY;
+    
+    if (apiKey) {
+      this.groq = new Groq({ apiKey });
+    } else {
+      this.groq = null; // Will be initialized in start()
+    }
     
     this.history = [];
     this.repoRoot = process.cwd();
@@ -99,10 +104,50 @@ class SmartAssistant {
           description: "Check the status of active sessions and locks",
           parameters: { type: "object", properties: {} }
         }
+      },
+      {
+        type: "function",
+        function: {
+          name: "resume_session",
+          description: "Resume an existing or orphaned session",
+          parameters: {
+            type: "object",
+            properties: {
+              sessionId: { type: "string", description: "The ID of the session to resume" },
+              taskName: { type: "string", description: "The task name to search for (optional)" }
+            },
+            required: ["sessionId"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "recover_sessions",
+          description: "Scan for and recover orphaned sessions from existing worktrees",
+          parameters: { type: "object", properties: {} }
+        }
       }
     ];
 
-    this.systemPrompt = `You are Kora, the Smart DevOps Assistant. 
+    // Load skills definition
+    let skillsDef = null;
+    try {
+      const skillsPath = path.join(__dirname, 'kora-skills.json');
+      if (fs.existsSync(skillsPath)) {
+        skillsDef = JSON.parse(fs.readFileSync(skillsPath, 'utf8'));
+      }
+    } catch (e) {
+      // Fallback if file missing or invalid
+      console.error('Warning: Could not load kora-skills.json, using defaults.');
+    }
+
+    if (skillsDef) {
+        // Build dynamic system prompt from skills definition
+        const allowedTopics = skillsDef.guardrails.allowed_topics.map(t => `- ${t}`).join('\n');
+        const disallowedTopics = skillsDef.guardrails.disallowed_topics.map(t => `- ${t}`).join('\n');
+        
+        this.systemPrompt = `You are ${skillsDef.assistant_name}, the ${skillsDef.role}.
 Your goal is to help developers follow the House Rules and Contract System while being helpful and efficient.
 
 CONTEXT:
@@ -111,22 +156,81 @@ CONTEXT:
 - Users need to create "Sessions" to do work.
 - You can execute tools to help the user.
 
-STYLE:
+CAPABILITIES (ALLOWED):
+${allowedTopics}
+
+GUARDRAILS (STRICTLY PROHIBITED):
+${disallowedTopics}
+
+AVAILABLE TOOLS:
+1. get_house_rules_summary - Read the project's rules.
+2. list_contracts - Check what contract files exist.
+3. check_session_status - See active work sessions.
+4. start_session - Begin a new task.
+5. resume_session - Resume an existing or orphaned session.
+6. recover_sessions - Scan and restore lost session locks.
+
+IMPORTANT INSTRUCTIONS:
+- ONLY use the tools listed above. Do NOT invent new tools like "check_compliance" or "run_tests".
+- If the user asks for something OUTSIDE your capabilities, you MUST reply with exactly this message:
+  "${skillsDef.guardrails.fallback_response}"
+- Be concise but helpful.
+- Identify yourself as "${skillsDef.assistant_name}".
+- If the user asks about starting a task, ask for a clear task name if not provided.
+- If the user asks about rules, summarize them from the actual files.
+- If the user wants to resume work, use check_session_status first.
+- If a session seems missing but worktree exists, use recover_sessions.
+- Always prefer "Structured" organization for new code.
+
+When you want to perform an action, use the available tools.`;
+    } else {
+        // Fallback static prompt
+        this.systemPrompt = `You are Kora, the Smart DevOps Assistant. 
+Your goal is to help developers follow the House Rules and Contract System while being helpful and efficient.
+
+CONTEXT:
+- You are running inside a "DevOps Agent" environment.
+- The project follows a strict "Contract System" (API, DB, Features, etc.).
+- Users need to create "Sessions" to do work.
+- You can execute tools to help the user.
+
+AVAILABLE TOOLS:
+1. get_house_rules_summary - Read the project's rules.
+2. list_contracts - Check what contract files exist.
+3. check_session_status - See active work sessions.
+4. start_session - Begin a new task.
+5. resume_session - Resume an existing or orphaned session.
+6. recover_sessions - Scan and restore lost session locks.
+
+IMPORTANT INSTRUCTIONS:
+- ONLY use the tools listed above. Do NOT invent new tools like "check_compliance" or "run_tests".
+- If a user asks for something you can't do with a tool (like running tests), tell them you can't do it yet but they can run "npm test" themselves.
 - Be concise but helpful.
 - Identify yourself as "Kora".
 - If the user asks about starting a task, ask for a clear task name if not provided.
 - If the user asks about rules, summarize them from the actual files.
+- If the user wants to resume work, use check_session_status first.
+- If a session seems missing but worktree exists, use recover_sessions.
 - Always prefer "Structured" organization for new code.
 
 When you want to perform an action, use the available tools.`;
+    }
   }
 
   /**
    * Initialize the chat session
    */
   async start() {
+    // Ensure Groq client is initialized
+    if (!this.groq) {
+      const apiKey = credentialsManager.getGroqApiKey();
+      if (apiKey) {
+        this.groq = new Groq({ apiKey });
+      }
+    }
+
     // Check for Groq API Key
-    if (!credentialsManager.hasGroqApiKey()) {
+    if (!this.groq && !credentialsManager.hasGroqApiKey()) {
       console.log('\n' + '='.repeat(60));
       console.log(`${CONFIG.colors.yellow}⚠️  GROQ API KEY MISSING${CONFIG.colors.reset}`);
       console.log('='.repeat(60));
@@ -171,6 +275,41 @@ When you want to perform an action, use the available tools.`;
     console.log(`\n${CONFIG.colors.cyan}Hi! I'm Kora. How can I help you today?${CONFIG.colors.reset}`);
     console.log(`${CONFIG.colors.dim}(Try: "Start a new task for login", "Explain house rules", "Check contracts")${CONFIG.colors.reset}\n`);
 
+    // Check for command line arguments
+    const args = process.argv.slice(2);
+    const taskIndex = args.indexOf('--task') !== -1 ? args.indexOf('--task') : args.indexOf('-t');
+    
+    if (taskIndex !== -1 && args[taskIndex + 1]) {
+      const taskName = args[taskIndex + 1];
+      console.log(`\n${CONFIG.colors.cyan}Auto-starting session for task: ${taskName}${CONFIG.colors.reset}\n`);
+      await this.startSession({ taskName });
+      return; // Exit after session? Or continue chat? Usually session start spawns child and returns.
+      // startSession re-initializes readline after child exit, so we can continue chat.
+    }
+
+    // Check for auto-resume
+    const resumeIndex = args.indexOf('resume');
+    const sessionIdIndex = args.indexOf('--session-id');
+    
+    if (resumeIndex !== -1 || sessionIdIndex !== -1) {
+      let sessionId = null;
+      let taskName = null;
+      
+      if (sessionIdIndex !== -1 && args[sessionIdIndex + 1]) {
+        sessionId = args[sessionIdIndex + 1];
+      }
+      
+      if (taskIndex !== -1 && args[taskIndex + 1]) {
+        taskName = args[taskIndex + 1];
+      }
+      
+      if (sessionId || taskName) {
+        console.log(`\n${CONFIG.colors.cyan}Auto-resuming session...${CONFIG.colors.reset}\n`);
+        await this.resumeSession({ sessionId, taskName });
+        return;
+      }
+    }
+
     this.startReadline();
   }
 
@@ -292,6 +431,12 @@ When you want to perform an action, use the available tools.`;
           case 'start_session':
             result = await this.startSession(args);
             break;
+          case 'resume_session':
+            result = await this.resumeSession(args);
+            break;
+          case 'recover_sessions':
+            result = await this.recoverSessions();
+            break;
           default:
             result = JSON.stringify({ error: "Unknown tool" });
         }
@@ -351,15 +496,50 @@ When you want to perform an action, use the available tools.`;
 
   async listContracts() {
     const contractsDir = path.join(this.repoRoot, 'House_Rules_Contracts');
-    if (!fs.existsSync(contractsDir)) {
-      return JSON.stringify({ exists: false, message: "Contracts folder not found." });
+    const centralExists = fs.existsSync(contractsDir);
+    
+    // Recursive search for contracts (similar to setup script)
+    const findCommand = `find "${this.repoRoot}" -type f \\( -iname "*CONTRACT*.md" -o -iname "*CONTRACT*.json" \\) -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/local_deploy/*"`;
+    
+    let allFiles = [];
+    try {
+        const output = execSync(findCommand, { encoding: 'utf8' }).trim();
+        allFiles = output.split('\n').filter(Boolean);
+    } catch (e) {
+        // Find failed or no files
     }
 
-    const files = fs.readdirSync(contractsDir).filter(f => f.endsWith('.md') || f.endsWith('.json'));
-    return JSON.stringify({
-      exists: true,
-      files: files,
-      location: contractsDir
+    const requiredTypes = [
+      'FEATURES_CONTRACT.md', 'API_CONTRACT.md', 'DATABASE_SCHEMA_CONTRACT.md',
+      'SQL_CONTRACT.json', 'THIRD_PARTY_INTEGRATIONS.md', 'INFRA_CONTRACT.md'
+    ];
+
+    const status = {};
+    let scatteredCount = 0;
+    
+    requiredTypes.forEach(type => {
+        // Check if in central folder
+        const isCentral = fs.existsSync(path.join(contractsDir, type));
+        
+        // Check if anywhere in repo
+        const found = allFiles.filter(f => path.basename(f).toUpperCase() === type || path.basename(f).toUpperCase().includes(type.split('.')[0]));
+        
+        status[type] = {
+            central: isCentral,
+            foundCount: found.length,
+            locations: found.map(f => path.relative(this.repoRoot, f))
+        };
+        
+        if (!isCentral && found.length > 0) scatteredCount++;
+    });
+
+    return JSON.stringify({ 
+      centralFolderExists: centralExists,
+      scatteredContractsCount: scatteredCount,
+      details: status,
+      message: scatteredCount > 0 
+        ? "Contracts found scattered in repository. Recommend running 'npm run setup' to consolidate." 
+        : (centralExists ? "Contracts found in central folder." : "No contracts found.")
     });
   }
 
@@ -391,55 +571,138 @@ When you want to perform an action, use the available tools.`;
   }
 
   async startSession(args) {
-    const taskName = args.taskName;
+    const { taskName, description } = args;
     
-    console.log(`${CONFIG.colors.magenta}Kora > ${CONFIG.colors.reset}Starting new session for: ${taskName}...`);
+    console.log(`${CONFIG.colors.magenta}Kora > ${CONFIG.colors.reset}Starting session for task: ${taskName}...`);
     
-    // Close readline interface to release stdin for the child process
+    // Close readline interface
     if (this.rl) {
       this.rl.close();
       this.rl = null;
     }
 
-    // We need to run the session coordinator interactively
-    // We'll use the 'create-and-start' command to jump straight to the task
     const scriptPath = path.join(__dirname, 'session-coordinator.js');
     
     return new Promise((resolve, reject) => {
-      // Use 'inherit' for stdio to allow interactive input/output
       const child = spawn('node', [scriptPath, 'create-and-start', '--task', taskName], {
         stdio: 'inherit',
         cwd: this.repoRoot
       });
       
       child.on('close', (code) => {
-        // Re-initialize readline interface after child process exits
         this.startReadline();
+        if (code === 0) {
+          resolve(JSON.stringify({ success: true, message: "Session started successfully." }));
+        } else {
+          resolve(JSON.stringify({ success: false, message: `Session process exited with code ${code}.` }));
+        }
+        console.log(`\n${CONFIG.colors.cyan}Welcome back to Kora!${CONFIG.colors.reset}`);
+      });
+      
+      child.on('error', (err) => {
+        this.startReadline();
+        resolve(JSON.stringify({ success: false, error: err.message }));
+      });
+    });
+  }
 
+  async recoverSessions() {
+    console.log(`${CONFIG.colors.magenta}Kora > ${CONFIG.colors.reset}Scanning for orphaned sessions to recover...`);
+    
+    // Close readline interface
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+
+    const scriptPath = path.join(__dirname, 'session-coordinator.js');
+    
+    return new Promise((resolve, reject) => {
+      const child = spawn('node', [scriptPath, 'recover'], {
+        stdio: 'inherit',
+        cwd: this.repoRoot
+      });
+      
+      child.on('close', (code) => {
+        this.startReadline();
         if (code === 0) {
-          resolve(JSON.stringify({
-            success: true,
-            message: `Session for '${taskName}' completed successfully.`
+          // Instead of generic message, suggest checking status
+          resolve(JSON.stringify({ 
+            success: true, 
+            message: "Recovery scan complete. Please run 'check_session_status' to see recovered sessions." 
           }));
         } else {
-          resolve(JSON.stringify({
-            success: false,
-            message: `Session process exited with code ${code}.`
-          }));
+          resolve(JSON.stringify({ success: false, message: `Recovery process exited with code ${code}.` }));
+        }
+        // Don't print "Welcome back" here to keep flow cleaner
+      });
+      
+      child.on('error', (err) => {
+        this.startReadline();
+        resolve(JSON.stringify({ success: false, error: err.message }));
+      });
+    });
+  }
+  async resumeSession(args) {
+    const { sessionId, taskName } = args;
+    
+    console.log(`${CONFIG.colors.magenta}Kora > ${CONFIG.colors.reset}Resuming session: ${sessionId || taskName}...`);
+    
+    // Close readline interface
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+
+    const scriptPath = path.join(__dirname, 'session-coordinator.js');
+    
+    // Construct arguments for session coordinator
+    // We use the 'resume' command if we have an ID, or create-and-start with task if we're fuzzy matching
+    // But actually session-coordinator doesn't have a direct 'resume' command exposed easily via CLI args 
+    // that jumps straight to monitoring without prompts, EXCEPT via the way createSession handles existing sessions.
+    // However, createSession with --task will prompt.
+    // Let's use a new approach: pass --resume-session-id if we have it.
+    
+    // Wait, session-coordinator.js CLI handling (which I can't fully see but I saw 'create' and 'list')
+    // I need to check how to invoke resume.
+    // Looking at session-coordinator.js (which I read), it has 'requestSession' and 'createSession'.
+    // It doesn't seem to have a direct CLI command for 'resume' that takes an ID.
+    // However, 'create-and-start' (implied by startSession usage) might support it?
+    // In startSession: [scriptPath, 'create-and-start', '--task', taskName, '--skip-setup', '--skip-update']
+    
+    // If I use 'create-and-start' with the SAME task name, it triggers the "Found existing session" logic
+    // but that logic is interactive (prompts Y/n).
+    
+    // I should probably add a CLI command to session-coordinator.js to resume by ID non-interactively,
+    // OR just use the 'worker' command directly if I know the worktree?
+    // But the coordinator handles setting up the environment.
+    
+    // Let's assume for now we can use a new 'resume' command in session-coordinator.js
+    // I will need to implement that in session-coordinator.js as well.
+    // But first let's implement the caller here.
+    
+    const cmdArgs = ['resume', '--session-id', sessionId];
+    if (taskName) cmdArgs.push('--task', taskName);
+    
+    return new Promise((resolve, reject) => {
+      const child = spawn('node', [scriptPath, ...cmdArgs], {
+        stdio: 'inherit',
+        cwd: this.repoRoot
+      });
+      
+      child.on('close', (code) => {
+        this.startReadline();
+        if (code === 0) {
+          resolve(JSON.stringify({ success: true, message: "Session resumed successfully." }));
+        } else {
+          resolve(JSON.stringify({ success: false, message: `Session process exited with code ${code}.` }));
         }
-        
-        // Resume the chat interface after the child process exits
         console.log(`\n${CONFIG.colors.cyan}Welcome back to Kora!${CONFIG.colors.reset}`);
       });
       
       child.on('error', (err) => {
-        // Re-initialize readline interface on error
         this.startReadline();
-        
-        resolve(JSON.stringify({
-          success: false,
-          error: err.message
-        }));
+        resolve(JSON.stringify({ success: false, error: err.message }));
       });
     });
   }