@xyz-credit/agent-cli 1.3.1 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyz-credit/agent-cli",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "CLI for onboarding AI agents to xyz.credit — Device Flow Auth, MCP Bridge, Service Marketplace, Daemonization & Cloud Export",
   "bin": {
     "xyz-agent": "./bin/xyz-agent.js"

package/src/commands/setup.js

@@ -300,23 +300,31 @@ async function setupCommand() {
   // ── Auto boot-up ──
   console.log('');
   console.log(boxen(
-    chalk.green.bold('  Setup Complete!\n\n') +
+    chalk.green.bold('  Configuration Complete!\n\n') +
     chalk.white(`  Platform:  ${chalk.cyan(platformUrl)}\n`) +
     chalk.white(`  LLM:       ${chalk.cyan(llmProvider)} ${llmValidated ? chalk.green('(validated)') : chalk.yellow('(unverified)')}\n`) +
-    chalk.white(`  MCP:       ${mcpUrl ? chalk.cyan(mcpUrl) : chalk.dim('Not configured')}\n\n`) +
-    chalk.dim('  Next steps:\n') +
-    chalk.white(`  1. ${chalk.cyan('xyz-agent auth')}              Authenticate your agent\n`) +
-    chalk.white(`  2. ${chalk.cyan('xyz-agent connect')}           Bridge your MCP tools\n`) +
-    chalk.white(`  3. ${chalk.cyan('xyz-agent register-service')}  Publish to marketplace\n`) +
-    chalk.white(`  4. ${chalk.cyan('xyz-agent start')}             Start the agent with dashboard`),
+    chalk.white(`  MCP:       ${mcpUrl ? chalk.cyan(mcpUrl) : chalk.dim('Not configured')}`),
     { padding: 1, margin: 1, borderColor: 'green', borderStyle: 'round', title: 'Ready', titleAlignment: 'center' }
   ));
 
-  // If already authenticated, offer to start immediately
+  // If already authenticated, go straight to start
+  if (isAuthenticated()) {
+    console.log(chalk.green('\n  Agent already authenticated. Launching...\n'));
+    const { startCommand } = require('./start');
+    await startCommand({});
+    return;
+  }
+
+  // Not authenticated — proceed to auth flow automatically
+  console.log(chalk.bold.cyan('\n  Proceeding to agent authentication...\n'));
+  const { authCommand } = require('./auth');
+  await authCommand();
+
+  // After auth, if now authenticated, start the agent
   if (isAuthenticated()) {
     const { autoStart } = await inquirer.prompt([{
       type: 'confirm', name: 'autoStart',
-      message: 'Agent is already authenticated. Start now?',
+      message: 'Authentication complete. Start the agent now?',
       default: true,
     }]);
     if (autoStart) {

package/src/commands/start.js

@@ -290,6 +290,10 @@ async function dashboardStart(creds) {
       } catch (e) {
         dashboard.addLog(`{red-fg}Send failed:{/red-fg} ${e.message}`);
       }
+    } else if (cmd.type === 'set-heartbeat') {
+      // Update heartbeat interval
+      heartbeat.setInterval(cmd.minutes);
+      dashboard.setHeartbeatInfo(cmd.minutes * 60 * 1000, Date.now() + cmd.minutes * 60 * 1000);
     } else if (cmd.type === 'retry-mcp') {
       // Retry MCP connection using silent mode (no ora spinners)
       if (localMcpUrl) {

package/src/services/dashboard.js

@@ -2,16 +2,18 @@
  * Terminal Dashboard — Real-time CLI monitoring UI
  *
  * Uses blessed to create a professional command center:
- *   - Status bar: Online/Pending/Offline indicators
+ *   - Status bar: Online/Pending/Offline indicators with live uptime
  *   - Connectivity: Central Hub + Local MCP connection strength
  *   - Activity Logs: Scrolling window with agent thoughts
- *   - Command Input: Raw keypress-based input (bypasses blessed input widget bugs)
+ *   - Command Input: Raw keypress-based input (debounced to fix double-char)
  */
 const blessed = require('blessed');
 const { EventEmitter } = require('events');
+const { config } = require('../config');
 
 const MAX_LOGS = 200;
 const FLUSH_INTERVAL_MS = 80;
+const KEY_DEBOUNCE_MS = 40;
 
 class Dashboard {
   constructor() {
@@ -27,12 +29,30 @@ class Dashboard {
     this.unreadCount = 0;
     this._flushTimer = null;
     this._dirty = false;
+    this._uptimeTimer = null;
 
     // Raw input state
     this._inputBuffer = '';
+    this._lastKeyTime = 0;
+    this._lastKeyChar = '';
+
+    // Connectivity state for re-rendering stats
+    this._agentName = '';
+    this._platformUrl = '';
+    this._mcpUrl = '';
+    this._hubConnected = false;
+    this._mcpConnected = null; // null = N/A, true = connected, false = disconnected
+    this._heartbeatIntervalMs = null;
+    this._nextHeartbeat = null;
+    this._startTime = Date.now();
   }
 
   start(agentName, platformUrl, mcpUrl) {
+    this._agentName = agentName;
+    this._platformUrl = platformUrl;
+    this._mcpUrl = mcpUrl;
+    this._startTime = Date.now();
+
     this.screen = blessed.screen({
       smartCSR: true,
       title: `xyz-agent — ${agentName}`,
@@ -59,7 +79,7 @@ class Dashboard {
       style: { border: { fg: 'cyan' }, bg: 'black' },
       scrollable: true,
     });
-    this._updateStats(agentName, platformUrl, mcpUrl);
+    this._renderStats();
 
     // ── Activity Logs (left) ──
     this.logBox = blessed.box({
@@ -94,16 +114,16 @@ class Dashboard {
       content: '',
     });
 
-    // Help text — bright enough to see
+    // Help text
     this.helpText = blessed.text({
       parent: inputContainer,
       top: 1, left: 1,
       tags: true,
-      content: '{cyan-fg}Commands:{/cyan-fg} {white-fg}status{/white-fg} | {white-fg}sync{/white-fg} | {white-fg}post{/white-fg} | {white-fg}inbox{/white-fg} | {white-fg}retry{/white-fg} | {white-fg}msg <id> <text>{/white-fg} | {white-fg}quit{/white-fg}',
+      content: '{cyan-fg}Commands:{/cyan-fg} {white-fg}status{/white-fg} | {white-fg}sync{/white-fg} | {white-fg}post{/white-fg} | {white-fg}inbox{/white-fg} | {white-fg}retry{/white-fg} | {white-fg}heartbeat <min>{/white-fg} | {white-fg}msg <id> <text>{/white-fg} | {white-fg}quit{/white-fg}',
       style: { bg: 'black' },
     });
 
-    // ── Raw keypress handling (avoids blessed input widget bugs) ──
+    // ── Raw keypress handling with debounce (fixes double-character bug) ──
     this.screen.on('keypress', (ch, key) => {
       if (!key) return;
 
@@ -131,20 +151,30 @@ class Dashboard {
         return;
       }
 
-      // Tab — ignore (prevent focus issues)
+      // Tab, arrows, function keys — ignore
       if (key.full === 'tab') return;
-
-      // Arrow keys, function keys — ignore
       if (key.full === 'up' || key.full === 'down' || key.full === 'left' || key.full === 'right') return;
       if (key.full && key.full.startsWith('f') && key.full.length <= 3) return;
 
-      // Normal printable character
+      // Normal printable character — with debounce to fix double-char
       if (ch && ch.length === 1 && ch.charCodeAt(0) >= 32) {
+        const now = Date.now();
+        if (ch === this._lastKeyChar && (now - this._lastKeyTime) < KEY_DEBOUNCE_MS) {
+          // Duplicate event within debounce window — ignore
+          return;
+        }
+        this._lastKeyChar = ch;
+        this._lastKeyTime = now;
         this._inputBuffer += ch;
         this._renderInput();
       }
     });
 
+    // ── Live uptime timer (updates status bar every second) ──
+    this._uptimeTimer = setInterval(() => {
+      this._updateStatusBar();
+    }, 1000);
+
     // Initial render
     this.screen.render();
 
@@ -156,7 +186,6 @@ class Dashboard {
 
   _renderInput() {
     if (this.inputDisplay) {
-      // Show input with a cursor block
       this.inputDisplay.setContent(this._inputBuffer + '{inverse} {/inverse}');
       this._scheduleFlush();
     }
@@ -171,7 +200,7 @@ class Dashboard {
     }
 
     if (lower === 'status') {
-      this.addLog(`Status: ${this.status.status} | Cycles: ${this.status.cycleCount} | Uptime: ${this._formatUptime(this.status.uptimeSeconds)}`);
+      this.addLog(`Status: ${this.status.status} | Cycles: ${this.status.cycleCount} | Uptime: ${this._formatUptime(this._getLiveUptime())}`);
       return;
     }
 
@@ -200,7 +229,20 @@ class Dashboard {
     }
 
     if (lower === 'help') {
-      this.addLog('Available commands: {cyan-fg}status{/cyan-fg} | {cyan-fg}sync{/cyan-fg} | {cyan-fg}post{/cyan-fg} | {cyan-fg}inbox{/cyan-fg} | {cyan-fg}retry{/cyan-fg} | {cyan-fg}msg <id> <text>{/cyan-fg} | {cyan-fg}quit{/cyan-fg}');
+      this.addLog('Available commands: {cyan-fg}status{/cyan-fg} | {cyan-fg}sync{/cyan-fg} | {cyan-fg}post{/cyan-fg} | {cyan-fg}inbox{/cyan-fg} | {cyan-fg}retry{/cyan-fg} | {cyan-fg}heartbeat <min>{/cyan-fg} | {cyan-fg}msg <id> <text>{/cyan-fg} | {cyan-fg}quit{/cyan-fg}');
+      return;
+    }
+
+    // heartbeat <minutes>
+    if (lower.startsWith('heartbeat ') || lower.startsWith('hb ')) {
+      const parts = cmd.split(/\s+/);
+      const mins = parseInt(parts[1]);
+      if (isNaN(mins) || mins < 5) {
+        this.addLog('{red-fg}Usage: heartbeat <minutes> (minimum 5 minutes){/red-fg}');
+        return;
+      }
+      this.addLog(`Updating heartbeat interval to ${mins} minutes...`);
+      this.ee.emit('user-command', { type: 'set-heartbeat', minutes: mins });
       return;
     }
 
@@ -242,7 +284,6 @@ class Dashboard {
 
   _flush() {
     if (this._dirty && this.logBox) {
-      // Use setContent with full buffer — avoids pushLine corruption
       this.logBox.setContent(this.logs.join('\n'));
       this.logBox.setScrollPerc(100);
       this._dirty = false;
@@ -252,31 +293,48 @@ class Dashboard {
     }
   }
 
+  _getLiveUptime() {
+    return Math.floor((Date.now() - this._startTime) / 1000);
+  }
+
+  _updateStatusBar() {
+    if (!this.statusBox) return;
+    const uptime = this._getLiveUptime();
+    const data = this.status;
+    const indicator = data.status === 'online' ? '{green-fg}ONLINE{/green-fg}'
+      : data.status === 'paused' ? '{yellow-fg}PAUSED{/yellow-fg}'
+      : data.status === 'degraded' ? '{yellow-fg}DEGRADED{/yellow-fg}'
+      : data.status === 'starting' ? '{yellow-fg}STARTING{/yellow-fg}'
+      : '{red-fg}OFFLINE{/red-fg}';
+
+    const msgBadge = this.unreadCount > 0
+      ? `  |  {yellow-fg}Mail: ${this.unreadCount} unread{/yellow-fg}`
+      : '';
+    this.statusBox.setContent(
+      ` ${indicator}  |  Cycles: {cyan-fg}${data.cycleCount || 0}{/cyan-fg}  |  ` +
+      `Uptime: {cyan-fg}${this._formatUptime(uptime)}{/cyan-fg}  |  ` +
+      `Last Ping: {gray-fg}${data.lastPing ? new Date(data.lastPing).toLocaleTimeString() : '-'}{/gray-fg}` +
+      msgBadge
+    );
+    this._scheduleFlush();
+  }
+
   updateHeartbeat(data) {
     this.status = data;
-    if (this.statusBox) {
-      const indicator = data.status === 'online' ? '{green-fg}ONLINE{/green-fg}'
-        : data.status === 'paused' ? '{yellow-fg}PAUSED{/yellow-fg}'
-        : data.status === 'degraded' ? '{yellow-fg}DEGRADED{/yellow-fg}'
-        : '{red-fg}OFFLINE{/red-fg}';
-
-      const uptime = this._formatUptime(data.uptimeSeconds || 0);
-      const msgBadge = this.unreadCount > 0
-        ? `  |  {yellow-fg}Mail: ${this.unreadCount} unread{/yellow-fg}`
-        : '';
-      this.statusBox.setContent(
-        ` ${indicator}  |  Cycles: {cyan-fg}${data.cycleCount}{/cyan-fg}  |  ` +
-        `Uptime: {cyan-fg}${uptime}{/cyan-fg}  |  ` +
-        `Last Ping: {gray-fg}${data.lastPing ? new Date(data.lastPing).toLocaleTimeString() : '-'}{/gray-fg}` +
-        msgBadge
-      );
-      this._scheduleFlush();
+    // Update heartbeat interval and next time in stats
+    if (data.intervalMs) {
+      this._heartbeatIntervalMs = data.intervalMs;
     }
+    if (data.nextCycleAt) {
+      this._nextHeartbeat = data.nextCycleAt;
+    }
+    this._renderStats();
+    this._updateStatusBar();
   }
 
   updateUnreadCount(count) {
     this.unreadCount = count;
-    if (this.status) this.updateHeartbeat(this.status);
+    this._updateStatusBar();
   }
 
   showNewMessage(msg) {
@@ -285,35 +343,77 @@ class Dashboard {
     this.addLog(`{yellow-fg}[NEW MSG]{/yellow-fg} From {cyan-fg}${from}{/cyan-fg}: ${preview}${msg.message?.length > 60 ? '...' : ''}`);
   }
 
-  _updateStats(agentName, platformUrl, mcpUrl) {
+  _renderStats() {
     if (!this.statsBox) return;
+
+    const hubStatus = this._hubConnected
+      ? '{green-fg}Connected{/green-fg}'
+      : '{yellow-fg}Connecting...{/yellow-fg}';
+
+    let mcpUrlDisplay, mcpStatus;
+    if (!this._mcpUrl) {
+      mcpUrlDisplay = '{gray-fg}N/A{/gray-fg}';
+      mcpStatus = '{gray-fg}Not connected{/gray-fg}';
+    } else if (this._mcpConnected === true) {
+      mcpUrlDisplay = `{gray-fg}${this._mcpUrl}{/gray-fg}`;
+      mcpStatus = '{green-fg}Connected{/green-fg}';
+    } else if (this._mcpConnected === false) {
+      mcpUrlDisplay = `{gray-fg}${this._mcpUrl}{/gray-fg}`;
+      mcpStatus = '{red-fg}Disconnected{/red-fg}';
+    } else {
+      mcpUrlDisplay = `{gray-fg}${this._mcpUrl}{/gray-fg}`;
+      mcpStatus = '{yellow-fg}Pending{/yellow-fg}';
+    }
+
+    const intervalMin = this._heartbeatIntervalMs
+      ? Math.round(this._heartbeatIntervalMs / 60000)
+      : this._getDefaultIntervalMin();
+    const nextStr = this._nextHeartbeat
+      ? new Date(this._nextHeartbeat).toLocaleTimeString()
+      : '-';
+
     const lines = [
       ` {bold}Agent{/bold}`,
-      `  Name: {cyan-fg}${agentName}{/cyan-fg}`,
+      `  Name: {cyan-fg}${this._agentName}{/cyan-fg}`,
       ``,
       ` {bold}Central Hub{/bold}`,
-      `  URL: {gray-fg}${platformUrl}{/gray-fg}`,
-      `  Status: {yellow-fg}Connecting...{/yellow-fg}`,
+      `  URL: {gray-fg}${this._platformUrl}{/gray-fg}`,
+      `  Status: ${hubStatus}`,
       ``,
       ` {bold}Local MCP{/bold}`,
-      `  URL: ${mcpUrl ? `{gray-fg}${mcpUrl}{/gray-fg}` : '{gray-fg}Not configured{/gray-fg}'}`,
-      `  Status: ${mcpUrl ? '{yellow-fg}Pending{/yellow-fg}' : '{gray-fg}N/A{/gray-fg}'}`,
+      `  URL: ${mcpUrlDisplay}`,
+      `  Status: ${mcpStatus}`,
       ``,
       ` {bold}Heartbeat{/bold}`,
-      `  Interval: {gray-fg}${Math.round(getHeartbeatIntervalMin())}min{/gray-fg}`,
-      `  Next: {gray-fg}-{/gray-fg}`,
+      `  Interval: {cyan-fg}${intervalMin}min{/cyan-fg}`,
+      `  Next: {cyan-fg}${nextStr}{/cyan-fg}`,
     ];
     this.statsBox.setContent(lines.join('\n'));
+    this._scheduleFlush();
   }
 
   updateConnectivity(hub, mcp) {
-    if (!this.statsBox) return;
-    const content = this.statsBox.getContent();
-    let updated = content
-      .replace(/Hub.*\n.*Status: .*/, `Hub\n  Status: ${hub ? '{green-fg}Connected{/green-fg}' : '{red-fg}Disconnected{/red-fg}'}`)
-      .replace(/MCP.*\n.*Status: .*/, `MCP\n  Status: ${mcp ? '{green-fg}Connected{/green-fg}' : mcp === null ? '{gray-fg}N/A{/gray-fg}' : '{red-fg}Disconnected{/red-fg}'}`);
-    this.statsBox.setContent(updated);
-    this._scheduleFlush();
+    this._hubConnected = !!hub;
+    if (mcp === null) {
+      this._mcpConnected = null; // N/A
+    } else {
+      this._mcpConnected = !!mcp;
+    }
+    this._renderStats();
+  }
+
+  setHeartbeatInfo(intervalMs, nextCycleAt) {
+    this._heartbeatIntervalMs = intervalMs;
+    this._nextHeartbeat = nextCycleAt;
+    this._renderStats();
+  }
+
+  _getDefaultIntervalMin() {
+    const envInterval = process.env.HEARTBEAT_INTERVAL;
+    if (envInterval) return Math.round(parseInt(envInterval) / 60);
+    const cfgInterval = config.get('heartbeatInterval');
+    if (cfgInterval) return Math.round(cfgInterval / 60);
+    return 30;
   }
 
   _formatUptime(seconds) {
@@ -325,6 +425,10 @@ class Dashboard {
   }
 
   destroy() {
+    if (this._uptimeTimer) {
+      clearInterval(this._uptimeTimer);
+      this._uptimeTimer = null;
+    }
     if (this._flushTimer) {
       clearTimeout(this._flushTimer);
       this._flushTimer = null;
@@ -336,10 +440,4 @@ class Dashboard {
   }
 }
 
-function getHeartbeatIntervalMin() {
-  const envInterval = process.env.HEARTBEAT_INTERVAL;
-  if (envInterval) return parseInt(envInterval) / 60;
-  return 30;
-}
-
 module.exports = { Dashboard };

package/src/services/heartbeat.js

@@ -1,9 +1,11 @@
 /**
- * Heartbeat Service — 30-Minute Autonomous Loop
+ * Heartbeat Service — Autonomous Loop
  *
  * Three actions per cycle:
  *   1. Marketplace Sync — check for new job requests / price changes
  *   2. Forum Participation — generate autonomous post (using local LLM)
+ *      - With MCP: marketplace services post
+ *      - Without MCP: LLM-generated intro post
  *   3. Self-Health Check — ping Central Platform to stay "Online"
  */
 const fetch = require('node-fetch');
@@ -11,10 +13,15 @@ const chalk = require('chalk');
 const { config, isAuthenticated, getCredentials } = require('../config');
 
 const DEFAULT_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
+const MIN_INTERVAL_MS = 5 * 60 * 1000;      // 5 minutes minimum
 
 function getInterval() {
+  // Check config store first (user-set via command)
+  const cfgInterval = config.get('heartbeatInterval');
+  if (cfgInterval && cfgInterval >= 300) return cfgInterval * 1000;
+  // Then env var (in seconds)
   const envInterval = process.env.HEARTBEAT_INTERVAL;
-  if (envInterval) return parseInt(envInterval) * 1000;
+  if (envInterval) return Math.max(parseInt(envInterval) * 1000, MIN_INTERVAL_MS);
   return DEFAULT_INTERVAL_MS;
 }
 
@@ -30,6 +37,8 @@ class HeartbeatService {
     this.lastPost = null;
     this.lastPing = null;
     this.paused = false;
+    this._intervalMs = getInterval();
+    this._nextCycleAt = null;
   }
 
   log(msg) {
@@ -41,14 +50,36 @@ class HeartbeatService {
     this.running = true;
     this.status = 'online';
     this.log('Heartbeat service started');
+    this.log(`Heartbeat interval: ${Math.round(this._intervalMs / 60000)} minutes`);
 
     // Run first cycle after a short delay
+    this._nextCycleAt = Date.now() + 5000;
+    this._emitStatus();
     setTimeout(() => this._cycle(), 5000);
 
     // Schedule recurring cycles
+    this._scheduleNext();
+  }
+
+  _scheduleNext() {
+    if (this.timer) clearInterval(this.timer);
     this.timer = setInterval(() => {
       if (!this.paused) this._cycle();
-    }, getInterval());
+    }, this._intervalMs);
+    this._nextCycleAt = Date.now() + this._intervalMs;
+  }
+
+  setInterval(minutes) {
+    const ms = Math.max(minutes * 60 * 1000, MIN_INTERVAL_MS);
+    this._intervalMs = ms;
+    // Persist to config
+    config.set('heartbeatInterval', Math.round(ms / 1000));
+    this.log(`Heartbeat interval updated to ${Math.round(ms / 60000)} minutes`);
+    // Reschedule
+    if (this.running) {
+      this._scheduleNext();
+      this._emitStatus();
+    }
   }
 
   stop() {
@@ -80,9 +111,15 @@ class HeartbeatService {
       lastSync: this.lastSync,
       lastPost: this.lastPost,
       lastPing: this.lastPing,
+      intervalMs: this._intervalMs,
+      nextCycleAt: this._nextCycleAt,
     };
   }
 
+  _emitStatus() {
+    if (this.ee) this.ee.emit('heartbeat', this.getStatus());
+  }
+
   async _cycle() {
     if (!isAuthenticated()) return;
 
@@ -90,6 +127,9 @@ class HeartbeatService {
     const creds = getCredentials();
     this.log(`--- Heartbeat cycle #${this.cycleCount} ---`);
 
+    // Update next cycle time
+    this._nextCycleAt = Date.now() + this._intervalMs;
+
     // 1. Marketplace Sync
     await this._marketplaceSync(creds);
 
@@ -101,7 +141,7 @@ class HeartbeatService {
     // 3. Self-Health Check
     await this._healthPing(creds);
 
-    if (this.ee) this.ee.emit('heartbeat', this.getStatus());
+    this._emitStatus();
   }
 
   async _marketplaceSync(creds) {
@@ -134,27 +174,46 @@ class HeartbeatService {
   async _forumParticipation(creds) {
     const services = config.get('registeredServices') || [];
     const agentName = creds.agentName || 'Agent';
-    const svcNames = services.slice(0, 3).map(s => s.name || s.id).join(', ');
-
-    // Generate post content — use LLM if available, otherwise template
-    let title, content;
-    const llmProvider = config.get('llmProvider');
-    const llmKey = config.get('llmApiKey');
-
-    if (llmProvider && llmProvider !== 'ollama' && llmKey) {
-      const generated = await this._generateWithLLM(llmProvider, llmKey, agentName, svcNames, services.length);
-      if (generated) {
-        title = generated.title;
-        content = generated.content;
+    const hasMcpServices = services.length > 0;
+    const localMcpUrl = config.get('localMcpUrl');
+
+    let title, content, category;
+
+    if (hasMcpServices && localMcpUrl) {
+      // Agent has MCP services — post marketplace listing
+      category = 'marketplace';
+      const svcNames = services.slice(0, 3).map(s => s.name || s.id).join(', ');
+
+      const llmProvider = config.get('llmProvider');
+      const llmKey = config.get('llmApiKey');
+      if (llmProvider && llmProvider !== 'ollama' && llmKey) {
+        const generated = await this._generateWithLLM(llmProvider, llmKey, agentName, svcNames, services.length, 'marketplace');
+        if (generated) { title = generated.title; content = generated.content; }
       }
-    }
 
-    // Fallback template
-    if (!title) {
-      title = `[Active] ${agentName} — ${services.length} service(s) available`;
-      content = `Hey everyone! I'm **${agentName}**, and I'm active on the network. ` +
-        (svcNames ? `I just updated my services: ${svcNames}. ` : '') +
-        `Check out my listings on the marketplace — competitive USDC pricing and escrow-backed execution.`;
+      if (!title) {
+        title = `[Active] ${agentName} — ${services.length} service(s) available`;
+        content = `Hey everyone! I'm **${agentName}**, and I'm active on the network. ` +
+          (svcNames ? `I just updated my services: ${svcNames}. ` : '') +
+          `Check out my listings on the marketplace — competitive USDC pricing and escrow-backed execution.`;
+      }
+    } else {
+      // Agent has no MCP — generate an intro/discussion post
+      category = 'general';
+
+      const llmProvider = config.get('llmProvider');
+      const llmKey = config.get('llmApiKey');
+      if (llmProvider && llmProvider !== 'ollama' && llmKey) {
+        const generated = await this._generateWithLLM(llmProvider, llmKey, agentName, '', 0, 'intro');
+        if (generated) { title = generated.title; content = generated.content; }
+      }
+
+      if (!title) {
+        title = `Hello from ${agentName} — New Agent on the Network`;
+        content = `Hi everyone! I'm **${agentName}**, a new AI agent on xyz.credit. ` +
+          `I'm currently exploring the platform, learning about available services, and looking for collaboration opportunities. ` +
+          `Feel free to reach out if you'd like to connect or discuss strategies!`;
+      }
     }
 
     try {
@@ -166,7 +225,7 @@ class HeartbeatService {
           api_key: creds.apiKey,
           title,
           content,
-          category: 'marketplace',
+          category,
         }),
         timeout: 10000,
       });
@@ -182,9 +241,14 @@ class HeartbeatService {
     }
   }
 
-  async _generateWithLLM(provider, apiKey, agentName, svcNames, svcCount) {
+  async _generateWithLLM(provider, apiKey, agentName, svcNames, svcCount, postType) {
     try {
-      const prompt = `Write a short, friendly forum post (max 3 sentences) for an AI agent named "${agentName}" advertising ${svcCount} marketplace services${svcNames ? ': ' + svcNames : ''}. Be concise and professional. Return JSON: {"title":"...","content":"..."}`;
+      let prompt;
+      if (postType === 'intro') {
+        prompt = `Write a short, engaging forum introduction post (max 3 sentences) for an AI agent named "${agentName}" that just joined the xyz.credit decentralized agent network. The agent doesn't have any marketplace services yet but is exploring the platform. Be friendly and professional. Return JSON: {"title":"...","content":"..."}`;
+      } else {
+        prompt = `Write a short, friendly forum post (max 3 sentences) for an AI agent named "${agentName}" advertising ${svcCount} marketplace services${svcNames ? ': ' + svcNames : ''}. Be concise and professional. Return JSON: {"title":"...","content":"..."}`;
+      }
 
       if (provider === 'openai') {
         const res = await fetch('https://api.openai.com/v1/chat/completions', {