codexbot 1.0.0 → 1.0.1

package/README.md

@@ -36,7 +36,7 @@ npm install -g codexbot
 Or install from source:
 
 ```bash
-git clone https://github.com/nicklama/codexbot.git
+git clone https://github.com/dinhquan/codexbot.git
 cd codexbot
 npm install
 npm link

package/cli.js

@@ -1,23 +1,50 @@
 #!/usr/bin/env node
 
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
 const args = process.argv.slice(2);
 const command = args[0];
 
+function getVersion() {
+  try {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf-8'));
+    return pkg.version;
+  } catch {
+    return '0.0.0';
+  }
+}
+
 function showHelp() {
+  const version = getVersion();
   console.log(`
-codexbot - Bridge Slack/Telegram to Claude/Codex via their SDKs
+  🤖 codexbot v${version}
+  Bridge Slack & Telegram to Claude/Codex AI agents
+
+  ─────────────────────────────────────────────────
+
+  📦 Commands:
+    codexbot start [options]    Start the bot as a background service
+    codexbot stop               Stop the background service
+    codexbot status             Show service status
+    codexbot onboard            Interactive setup wizard
+
+  ⚙️  Options:
+    --interactive               Run in interactive terminal mode
+    --claude                    Use Claude Agent SDK (default: Codex)
+    --disable-yolo              Disable auto-accept mode
+    --help, -h                  Show this help message
 
-Usage:
-  codexbot start [options]      Start the bot as a background service
-  codexbot stop                 Stop the background service
-  codexbot status               Show service status
-  codexbot onboard              Interactive setup (platform, tokens, config)
+  📖 Examples:
+    codexbot onboard            Set up platform & tokens
+    codexbot start              Launch as background service
+    codexbot start --claude     Launch with Claude backend
+    codexbot start --interactive --claude
+                                Interactive terminal with Claude
 
-Options:
-  --interactive              Run in interactive terminal mode
-  --claude                   Use Claude Agent SDK instead of Codex SDK (default: Codex)
-  --disable-yolo             Disable auto-accept mode
-  --help, -h                 Show this help message
+  💡 Get started: run ${'\x1b[1m'}codexbot onboard${'\x1b[0m'} to configure your bot.
 `);
 }
 
@@ -58,7 +85,7 @@ switch (command) {
     showHelp();
     break;
   default:
-    console.error(`Unknown command: ${command}`);
+    console.error(`\n  ❌ Unknown command: ${command}\n`);
     showHelp();
     process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexbot",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "description": "Control Claude and Codex AI agents from Telegram or Slack",
   "keywords": [
@@ -47,4 +47,4 @@
     "@slack/web-api": "^7.13.0",
     "telegraf": "^4.16.0"
   }
-}
+}

package/src/agent.js

@@ -27,7 +27,7 @@ export default class Agent extends EventEmitter {
       this._initCodex();
     }
 
-    console.log(`[codexbot] Agent started (${this.backend}) in ${this.workingDir}`);
+    console.log(`  🤖 Agent started (${this.backend}) in ${this.workingDir}`);
   }
 
   async _initCodex() {
@@ -55,8 +55,8 @@ export default class Agent extends EventEmitter {
       }
     } catch (err) {
       if (err.name !== 'AbortError') {
-        console.error(`[codexbot] Agent error:`, err.message);
-        this.emit('message', `Error: ${err.message}`);
+        console.error(`  ❌ Agent error: ${err.message}`);
+        this.emit('message', `❌ Error: ${err.message}`);
       }
     } finally {
       this.busy = false;
@@ -254,7 +254,7 @@ export default class Agent extends EventEmitter {
     this._claudeSessionId = null;
     this.running = false;
     this.busy = false;
-    console.log('[codexbot] Agent stopped');
+    console.log('  ⏹️  Agent stopped');
   }
 
   getStatus() {

package/src/commands.js

@@ -8,6 +8,17 @@ export const COMMANDS = [
   { command: 'dir', description: 'Show or change working directory' },
 ];
 
+function formatUptime(totalSeconds) {
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  const parts = [];
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  parts.push(`${seconds}s`);
+  return parts.join(' ');
+}
+
 export function handle(text, agent) {
   const trimmed = text.trim();
   if (!trimmed.startsWith('$') && !trimmed.startsWith('/')) return { handled: false };
@@ -19,45 +30,52 @@ export function handle(text, agent) {
   switch (cmd) {
     case 'status': {
       const s = agent.getStatus();
-      const upMin = Math.floor(s.uptime / 60);
-      const upSec = s.uptime % 60;
-      const response = s.running
-        ? `Running: ${s.backend}${s.busy ? ' (busy)' : ''}\nUptime: ${upMin}m ${upSec}s\nCWD: ${s.cwd}`
-        : 'Agent is not running.';
-      return { handled: true, response };
+      if (s.running) {
+        const uptime = formatUptime(s.uptime);
+        const response = [
+          `✅ *Agent is running*`,
+          ``,
+          `🔧 Backend: \`${s.backend}\``,
+          `⏱️ Uptime:  ${uptime}`,
+          `📂 CWD:     \`${s.cwd}\``,
+          s.busy ? `⏳ Status:  Processing...` : `💤 Status:  Idle`,
+        ].join('\n');
+        return { handled: true, response };
+      }
+      return { handled: true, response: '⏸️ Agent is not running.\nUse /start to launch it.' };
     }
 
     case 'stop': {
       agent.stop();
-      return { handled: true, response: 'Agent stopped.' };
+      return { handled: true, response: '⏹️ Agent stopped.' };
     }
 
     case 'start': {
       if (agent.running) {
-        return { handled: true, response: 'Agent is already running.' };
+        return { handled: true, response: '✅ Agent is already running.' };
       }
       applyFlags(agent, parts.slice(1));
       agent.start();
-      return { handled: true, response: 'Agent started.' };
+      return { handled: true, response: `🚀 Agent started!\n🔧 Backend: \`${agent.backend}\`` };
     }
 
     case 'restart': {
       agent.stop();
       applyFlags(agent, parts.slice(1));
       agent.start();
-      return { handled: true, response: 'Agent restarted.' };
+      return { handled: true, response: `🔄 Agent restarted!\n🔧 Backend: \`${agent.backend}\`` };
     }
 
     case 'dir': {
       const dir = parts[1];
       if (!dir) {
-        return { handled: true, response: `Current directory: ${agent.workingDir}` };
+        return { handled: true, response: `📂 Current directory: \`${agent.workingDir}\`` };
       }
       if (!fs.existsSync(dir)) {
-        return { handled: true, response: `Directory not found: ${dir}` };
+        return { handled: true, response: `❌ Directory not found: \`${dir}\`` };
       }
       agent.workingDir = dir;
-      return { handled: true, response: `Working directory set to: ${dir}\nRestart agent for it to take effect.` };
+      return { handled: true, response: `📂 Working directory set to: \`${dir}\`\n💡 Use /restart for it to take effect.` };
     }
 
     default:

package/src/main.js

@@ -4,6 +4,10 @@ import Agent from './agent.js';
 import { handle as handleCommand, COMMANDS } from './commands.js';
 import { chunkMessage } from './chunker.js';
 
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+
 export async function start(args = []) {
   const interactive = args.includes('--interactive');
   const config = loadConfig();
@@ -22,26 +26,26 @@ export async function start(args = []) {
 
   if (!interactive) {
     if (!config.PLATFORM) {
-      console.error('No platform configured. Run "codexbot onboard" first.');
+      console.error(`\n  ❌ No platform configured. Run ${bold('codexbot onboard')} first.\n`);
       process.exit(1);
     }
 
     if (config.PLATFORM === 'slack') {
       if (!config.SLACK_BOT_TOKEN || !config.SLACK_APP_TOKEN) {
-        console.error('Missing Slack tokens. Run "codexbot onboard" to configure.');
+        console.error(`\n  ❌ Missing Slack tokens. Run ${bold('codexbot onboard')} to configure.\n`);
         process.exit(1);
       }
       const { default: SlackAdapter } = await import('./platforms/slack.js');
       platform = new SlackAdapter(config);
     } else if (config.PLATFORM === 'telegram') {
       if (!config.TELEGRAM_BOT_TOKEN) {
-        console.error('Missing Telegram bot token. Run "codexbot onboard" to configure.');
+        console.error(`\n  ❌ Missing Telegram bot token. Run ${bold('codexbot onboard')} to configure.\n`);
         process.exit(1);
       }
       const { default: TelegramAdapter } = await import('./platforms/telegram.js');
       platform = new TelegramAdapter(config);
     } else {
-      console.error(`Unknown platform: ${config.PLATFORM}`);
+      console.error(`\n  ❌ Unknown platform: ${config.PLATFORM}\n`);
       process.exit(1);
     }
   }
@@ -57,11 +61,11 @@ function startInteractive(agent) {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: '\nyou> ',
+    prompt: `\n${cyan('you')}${dim('>')} `,
   });
 
   agent.on('message', (text) => {
-    console.log(`\nbot> ${text}`);
+    console.log(`\n${cyan('bot')}${dim('>')} ${text}`);
     rl.prompt();
   });
 
@@ -70,7 +74,10 @@ function startInteractive(agent) {
   });
 
   agent.start();
-  console.log(`[codexbot] Interactive mode (${agent.backend}). Type your message or Ctrl+C to quit.\n`);
+  console.log(`\n  🤖 ${bold('codexbot Interactive Mode')}`);
+  console.log(`     Backend:  ${agent.backend}`);
+  console.log(`     CWD:      ${dim(agent.workingDir)}`);
+  console.log(`     ${dim('Type your message or Ctrl+C to quit.')}\n`);
   rl.prompt();
 
   rl.on('line', async (line) => {
@@ -86,13 +93,14 @@ function startInteractive(agent) {
 
     const sent = await agent.sendCommand(text);
     if (!sent) {
-      console.log('Agent is not running. Use $start to start it.');
+      console.log('  ⚠️  Agent is not running. Use $start to start it.');
       rl.prompt();
     }
   });
 
   rl.on('close', () => {
     agent.stop();
+    console.log(`\n  👋 Goodbye!\n`);
     process.exit(0);
   });
 }
@@ -134,7 +142,7 @@ function startService(agent, platform, config) {
     const sent = await agent.sendCommand(msg.text);
     if (!sent) {
       if (platform.stopTyping) platform.stopTyping();
-      await sendResponse(platform, currentCtx, 'Agent is not running. Use $start to start it.');
+      await sendResponse(platform, currentCtx, '⚠️ Agent is not running. Use /start to start it.');
     }
   });
 
@@ -145,14 +153,21 @@ function startService(agent, platform, config) {
     platform.setCommands(COMMANDS);
   }
 
+  const platformName = config.PLATFORM.charAt(0).toUpperCase() + config.PLATFORM.slice(1);
+
   platform.start().then(() => {
-    console.log('[codexbot] Bot is running. Press Ctrl+C to stop.');
+    console.log(`  ✅ ${bold('codexbot is running')}`);
+    console.log(`     Platform:  ${platformName}`);
+    console.log(`     Backend:   ${agent.backend}`);
+    console.log(`     CWD:       ${dim(agent.workingDir)}`);
+    console.log(`     ${dim('Press Ctrl+C to stop.')}`);
   });
 
   const shutdown = async () => {
-    console.log('\n[codexbot] Shutting down...');
+    console.log(`\n  ⏹️  Shutting down codexbot...`);
     agent.stop();
     await platform.stop().catch(() => { });
+    console.log(`  👋 Goodbye!\n`);
     process.exit(0);
   };
 
@@ -171,7 +186,7 @@ async function sendResponse(platform, ctx, text) {
         replyToMessageId: ctx.replyToMessageId,
       });
     } catch (err) {
-      console.error('[codexbot] Failed to send message:', err.message);
+      console.error(`  ❌ Failed to send message: ${err.message}`);
     }
   }
 }

package/src/onboard.js

@@ -4,29 +4,53 @@ import { loadConfig, saveConfig, CONFIG_PATH } from './config.js';
 
 const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+
 function ask(question, defaultVal) {
   return new Promise(resolve => {
-    const suffix = defaultVal ? ` [${defaultVal}]` : '';
-    rl.question(`${question}${suffix}: `, answer => {
+    const suffix = defaultVal ? dim(` [${defaultVal}]`) : '';
+    rl.question(`  ${question}${suffix}: `, answer => {
       resolve(answer.trim() || defaultVal || '');
     });
   });
 }
 
+function maskToken(token) {
+  if (!token || token.length < 10) return token || '';
+  return token.slice(0, 6) + '••••' + token.slice(-4);
+}
+
 async function onboard() {
-  console.log('\n=== codexbot Setup ===\n');
+  console.log(`
+  🤖 ${bold('codexbot Setup Wizard')}
+  ─────────────────────────────────────
+  `);
 
   const existing = loadConfig();
 
-  // If config exists, offer to keep it
+  // If config exists, show current state and offer to keep it
   if (existing.PLATFORM) {
-    console.log('Current config:');
-    console.log(`  Platform: ${existing.PLATFORM}`);
-    if (existing.WORKING_DIR) console.log(`  Working dir: ${existing.WORKING_DIR}`);
+    console.log(`  📋 ${bold('Current Configuration')}`);
+    console.log(`     Platform:    ${cyan(existing.PLATFORM)}`);
+    if (existing.PLATFORM === 'slack') {
+      console.log(`     Bot Token:   ${dim(maskToken(existing.SLACK_BOT_TOKEN))}`);
+      console.log(`     App Token:   ${dim(maskToken(existing.SLACK_APP_TOKEN))}`);
+      if (existing.SLACK_USER_ID) console.log(`     User ID:     ${dim(existing.SLACK_USER_ID)}`);
+    } else if (existing.PLATFORM === 'telegram') {
+      console.log(`     Bot Token:   ${dim(maskToken(existing.TELEGRAM_BOT_TOKEN))}`);
+      if (existing.TELEGRAM_ALLOWED_USER_IDS) console.log(`     Allowed IDs: ${dim(existing.TELEGRAM_ALLOWED_USER_IDS)}`);
+    }
+    if (existing.WORKING_DIR) console.log(`     Working Dir: ${dim(existing.WORKING_DIR)}`);
     console.log();
+
     const keep = await ask('Keep current config? (y/n)', 'y');
     if (keep.toLowerCase() === 'y') {
-      console.log('Config unchanged.');
+      console.log(`\n  ✅ Configuration unchanged.\n`);
       rl.close();
       return;
     }
@@ -35,14 +59,21 @@ async function onboard() {
 
   const config = { ...existing };
 
-  console.log('Choose platform:');
-  console.log('  1) Slack');
-  console.log('  2) Telegram');
+  // Step 1: Platform
+  console.log(`  ${bold('Step 1 of 3')} — ${cyan('Choose Platform')}\n`);
+  console.log(`     1) 💬 Slack`);
+  console.log(`     2) ✈️  Telegram\n`);
   const platformChoice = await ask('Platform (1 or 2)', config.PLATFORM === 'telegram' ? '2' : '1');
   config.PLATFORM = platformChoice === '2' ? 'telegram' : 'slack';
+  console.log(`\n  ✓ Platform: ${green(config.PLATFORM)}\n`);
+
+  // Step 2: Tokens
+  console.log(`  ${bold('Step 2 of 3')} — ${cyan('Configure Tokens')}\n`);
 
   if (config.PLATFORM === 'slack') {
-    console.log('\n--- Slack Configuration ---');
+    console.log(`  ${dim('You\'ll need a Slack Bot Token (xoxb-...) and App-Level Token (xapp-...).')}`);
+    console.log(`  ${dim('Create these at https://api.slack.com/apps')}\n`);
+
     config.SLACK_BOT_TOKEN = await ask('Bot Token (xoxb-...)', config.SLACK_BOT_TOKEN);
     config.SLACK_APP_TOKEN = await ask('App-Level Token (xapp-...)', config.SLACK_APP_TOKEN);
     config.SLACK_USER_ID = await ask('Your Slack User ID (optional, for auth)', config.SLACK_USER_ID);
@@ -50,7 +81,9 @@ async function onboard() {
     delete config.TELEGRAM_BOT_TOKEN;
     delete config.TELEGRAM_ALLOWED_USER_IDS;
   } else {
-    console.log('\n--- Telegram Configuration ---');
+    console.log(`  ${dim('You\'ll need a Telegram Bot Token from @BotFather.')}`);
+    console.log(`  ${dim('Message @BotFather on Telegram to create a bot.')}\n`);
+
     config.TELEGRAM_BOT_TOKEN = await ask('Bot Token', config.TELEGRAM_BOT_TOKEN);
     config.TELEGRAM_ALLOWED_USER_IDS = await ask('Allowed User IDs (comma-separated, optional)', config.TELEGRAM_ALLOWED_USER_IDS);
     // Clear slack keys
@@ -59,23 +92,34 @@ async function onboard() {
     delete config.SLACK_USER_ID;
   }
 
+  console.log(`\n  ✓ Tokens configured\n`);
+
+  // Step 3: Working directory
+  console.log(`  ${bold('Step 3 of 3')} — ${cyan('Set Working Directory')}\n`);
+  console.log(`  ${dim('The agent will execute commands in this directory.')}\n`);
+
   let workingDir = config.WORKING_DIR || process.cwd();
   while (true) {
-    workingDir = await ask('\nWorking directory (optional)', workingDir);
+    workingDir = await ask('Working directory', workingDir);
     if (!workingDir || fs.existsSync(workingDir)) break;
-    console.log(`Directory does not exist: ${workingDir}`);
+    console.log(`  ${yellow('⚠')}  Directory does not exist: ${workingDir}`);
   }
   config.WORKING_DIR = workingDir;
 
+  console.log(`\n  ✓ Working directory: ${green(workingDir)}\n`);
+
+  // Save
   saveConfig(config);
-  console.log(`\nConfig saved to ${CONFIG_PATH}`);
-  console.log('Run "codexbot start" to launch the bot.\n');
+  console.log(`  ─────────────────────────────────────`);
+  console.log(`\n  ✅ ${bold('Setup complete!')}`);
+  console.log(`  📁 Config saved to ${dim(CONFIG_PATH)}`);
+  console.log(`\n  🚀 Run ${bold('codexbot start')} to launch your bot.\n`);
 
   rl.close();
 }
 
 onboard().catch(err => {
-  console.error('Setup failed:', err.message);
+  console.error(`\n  ❌ Setup failed: ${err.message}\n`);
   rl.close();
   process.exit(1);
 });

package/src/platforms/slack.js

@@ -42,7 +42,7 @@ export default class SlackAdapter {
     });
 
     await this.app.start();
-    console.log('[codexbot] Slack connected (Socket Mode)');
+    console.log('  💬 Slack connected (Socket Mode)');
   }
 
   onMessage(callback) {

package/src/platforms/telegram.js

@@ -43,7 +43,7 @@ export default class TelegramAdapter {
       this.bot.telegram.setMyCommands(this._commands).catch(() => { });
     }
 
-    console.log('[codexbot] Telegram bot started');
+    console.log('  ✈️  Telegram bot connected');
 
     // Graceful stop on signals
     process.once('SIGINT', () => this.bot.stop('SIGINT'));

package/src/service.js

@@ -9,16 +9,21 @@ const LOG_FILE = path.join(CONFIG_DIR, 'codexbot.log');
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CLI_PATH = path.join(__dirname, '..', 'cli.js');
 
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+
 export function startService(args = []) {
   const config = loadConfig();
   if (!config.PLATFORM) {
-    console.error('No platform configured. Run "codexbot onboard" first.');
+    console.error(`\n  ❌ No platform configured.\n     Run ${bold('codexbot onboard')} to set up your bot.\n`);
     process.exit(1);
   }
 
   const existing = getServicePid();
   if (existing) {
-    console.error(`codexbot is already running (PID ${existing}). Use "codexbot stop" first.`);
+    console.error(`\n  ⚠️  codexbot is already running ${dim(`(PID ${existing})`)}`);
+    console.error(`     Use ${bold('codexbot stop')} first, or ${bold('codexbot status')} to check.\n`);
     process.exit(1);
   }
 
@@ -36,45 +41,66 @@ export function startService(args = []) {
   child.unref();
   fs.closeSync(logFd);
 
-  console.log(`codexbot started (PID ${child.pid})`);
-  console.log(`Logs: ${LOG_FILE}`);
+  const backend = args.includes('--claude') ? 'Claude' : 'Codex';
+  const platform = config.PLATFORM.charAt(0).toUpperCase() + config.PLATFORM.slice(1);
+
+  console.log(`\n  🚀 ${bold('codexbot started!')}`);
+  console.log(`     PID:       ${dim(String(child.pid))}`);
+  console.log(`     Platform:  ${platform}`);
+  console.log(`     Backend:   ${backend}`);
+  console.log(`     Logs:      ${dim(LOG_FILE)}`);
+  console.log(`\n  💡 Use ${bold('codexbot status')} to check health or ${bold('codexbot stop')} to shut down.\n`);
 }
 
 export function stopService() {
   const pid = getServicePid();
   if (!pid) {
-    console.log('codexbot is not running.');
+    console.log(`\n  ℹ️  codexbot is not running. Nothing to stop.\n`);
     return;
   }
 
   try {
     process.kill(pid, 'SIGTERM');
-    console.log(`codexbot stopped (PID ${pid})`);
+    cleanupPid();
+    console.log(`\n  ⏹️  ${bold('codexbot stopped')} ${dim(`(PID ${pid})`)}`);
+    console.log(`     Run ${bold('codexbot start')} to launch again.\n`);
   } catch (err) {
     if (err.code === 'ESRCH') {
-      console.log('codexbot process not found (stale PID file). Cleaning up.');
+      cleanupPid();
+      console.log(`\n  ⚠️  Process not found ${dim(`(PID ${pid})`)} — stale PID file cleaned up.`);
+      console.log(`     codexbot was not actually running.\n`);
     } else {
-      console.error(`Failed to stop codexbot: ${err.message}`);
+      console.error(`\n  ❌ Failed to stop codexbot: ${err.message}\n`);
     }
   }
-
-  cleanupPid();
 }
 
 export function showStatus() {
   const pid = getServicePid();
   if (!pid) {
-    console.log('codexbot is not running.');
+    console.log(`\n  ⏸️  codexbot is ${bold('not running')}`);
+    console.log(`     Run ${bold('codexbot start')} to launch.\n`);
     return;
   }
 
   const alive = isProcessAlive(pid);
   if (alive) {
-    console.log(`codexbot is running (PID ${pid})`);
-    console.log(`Logs: ${LOG_FILE}`);
+    const config = loadConfig();
+    const platform = config.PLATFORM
+      ? config.PLATFORM.charAt(0).toUpperCase() + config.PLATFORM.slice(1)
+      : 'Unknown';
+    const pidStartTime = getPidFileAge();
+
+    console.log(`\n  ${green('●')} codexbot is ${bold('running')}`);
+    console.log(`     PID:       ${dim(String(pid))}`);
+    console.log(`     Platform:  ${platform}`);
+    if (pidStartTime) console.log(`     Since:     ${dim(pidStartTime)}`);
+    console.log(`     Logs:      ${dim(LOG_FILE)}`);
+    console.log();
   } else {
-    console.log('codexbot is not running (stale PID file). Cleaning up.');
     cleanupPid();
+    console.log(`\n  ⚠️  codexbot is ${bold('not running')} ${dim('(stale PID file cleaned up)')}`);
+    console.log(`     Run ${bold('codexbot start')} to launch.\n`);
   }
 }
 
@@ -99,3 +125,12 @@ function isProcessAlive(pid) {
 function cleanupPid() {
   try { fs.unlinkSync(PID_FILE); } catch { }
 }
+
+function getPidFileAge() {
+  try {
+    const stat = fs.statSync(PID_FILE);
+    return stat.mtime.toLocaleString();
+  } catch {
+    return null;
+  }
+}