@moltium/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2722 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command7 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { mkdir, writeFile } from "fs/promises";
+import { join, resolve } from "path";
+import { existsSync } from "fs";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import ora from "ora";
+
+// src/templates/code-based/index.ts
+function codeTemplate(ctx) {
+  const envKey = ctx.llmProvider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+  const model = ctx.llmProvider === "anthropic" ? "claude-sonnet-4-20250514" : "gpt-4o";
+  const socialConfig = buildSocialConfig(ctx.socialPlatforms);
+  return `import type { AgentConfig } from '@moltium/core';
+import { exampleAction } from './actions/example.js';
+
+export default {
+  name: '${ctx.name}',
+  type: '${ctx.type}',
+
+  personality: {
+    traits: ['helpful', 'curious', 'thoughtful'],
+    bio: 'A versatile autonomous agent built with Moltium.',
+  },
+
+  llm: {
+    provider: '${ctx.llmProvider}',
+    model: '${model}',
+    apiKey: process.env.${envKey}!,
+    temperature: 0.7,
+    maxTokens: 2048,
+  },
+
+  social: {${socialConfig}
+  },
+
+  behaviors: {
+    autonomous: true,
+    decisionMaking: 'llm-driven',
+    actionsPerHour: 5,
+    sleepSchedule: { start: 22, end: 6, timezone: 'UTC' },
+  },
+
+  memory: {
+    type: 'memory',
+    retention: '30d',
+  },
+
+  actions: [
+    'post_social_update',
+    'respond_to_mention',
+    'schedule_task',
+  ],
+
+  // Register your custom actions here.
+  // Create new actions in the actions/ directory and import them above.
+  customActions: [
+    exampleAction,
+  ],
+
+} satisfies AgentConfig;
+`;
+}
+function buildSocialConfig(platforms) {
+  const parts = [];
+  if (platforms.includes("moltbook")) {
+    parts.push(`
+    moltbook: {
+      enabled: true,
+      apiKey: process.env.MOLTBOOK_API_KEY!,
+      postFrequency: 'hourly',
+      engagementRate: 'medium',
+      autoReply: true,
+    },`);
+  }
+  if (platforms.includes("twitter")) {
+    parts.push(`
+    twitter: {
+      enabled: true,
+      credentials: {
+        apiKey: process.env.TWITTER_API_KEY!,
+        apiSecret: process.env.TWITTER_API_SECRET!,
+        accessToken: process.env.TWITTER_ACCESS_TOKEN!,
+        accessSecret: process.env.TWITTER_ACCESS_SECRET!,
+      },
+      postFrequency: 'daily',
+      replyToMentions: true,
+      maxTweetsPerDay: 5,
+    },`);
+  }
+  return parts.join("");
+}
+
+// src/templates/code-based/start.ts
+function codeStartTemplate(ctx) {
+  return `import 'dotenv/config';
+import { Agent, startServer } from '@moltium/core';
+import config from './agent.config.js';
+import { onInit } from './hooks/onInit.js';
+import { onTick } from './hooks/onTick.js';
+import { onShutdown } from './hooks/onShutdown.js';
+
+/**
+ * ${ctx.name} \u2014 Entry Point
+ *
+ * This file boots your agent. It:
+ * 1. Loads the agent configuration from agent.config.ts
+ * 2. Wires up lifecycle hooks (onInit, onTick, onShutdown)
+ * 3. Starts the HTTP server with REST endpoints
+ *
+ * Run with:  npx tsx start.ts
+ * Or:        npm start
+ */
+
+const agent = new Agent(config, {
+  onInit,
+  onTick,
+  onShutdown,
+  onError: async (error, agent) => {
+    console.error(\`[\${agent.name}] Error:\`, error.message);
+  },
+});
+
+const port = parseInt(process.env.PORT || '3000', 10);
+
+startServer(agent, { port }).catch((err) => {
+  console.error('Failed to start agent:', err);
+  process.exit(1);
+});
+`;
+}
+
+// src/templates/code-based/action.ts
+function exampleActionTemplate(ctx) {
+  return `import type { Action, ActionContext, ActionResult } from '@moltium/core';
+
+/**
+ * Example custom action for ${ctx.name}.
+ *
+ * Actions are the building blocks of agent behavior. Each action:
+ * - Has a unique name used to trigger it
+ * - Receives context with access to memory, LLM, and parameters
+ * - Returns a result indicating success/failure with optional data
+ *
+ * To create more actions, copy this file and register them in agent.config.ts.
+ */
+export const exampleAction: Action = {
+  name: 'example_action',
+  description: 'An example custom action \u2014 replace with your own logic',
+
+  async execute(context: ActionContext): Promise<ActionResult> {
+    const { parameters, memory, llm } = context;
+
+    // 1. Read from memory
+    const previousResult = await memory.recall('last_example_result');
+
+    // 2. Use the LLM to generate a response
+    const response = await llm.generateText(
+      \`You are a \${${JSON.stringify(ctx.type)}} agent. Given the following input, produce a helpful response.
+
+Input: \${JSON.stringify(parameters)}
+Previous context: \${previousResult || 'None'}
+
+Respond concisely.\`,
+      { temperature: 0.7, maxTokens: 512 },
+    );
+
+    // 3. Store result in memory for next time
+    await memory.remember('last_example_result', response, 3600);
+
+    return {
+      success: true,
+      data: {
+        response,
+        processedAt: new Date().toISOString(),
+      },
+    };
+  },
+};
+`;
+}
+
+// src/templates/code-based/hooks.ts
+function onInitTemplate(ctx) {
+  return `import type { Agent } from '@moltium/core';
+
+/**
+ * Called once when the agent initializes, before the autonomous loop starts.
+ * Use this to load initial data, connect to external services, or set up state.
+ */
+export async function onInit(agent: Agent): Promise<void> {
+  const memory = agent.getMemory();
+
+  // Load any persisted state from a previous session
+  const sessionCount = ((await memory.retrieve('session_count')) as number) || 0;
+  await memory.store('session_count', sessionCount + 1);
+  await memory.store('init_time', new Date().toISOString());
+
+  console.log(\`[${ctx.name}] Initialized (session #\${sessionCount + 1})\`);
+}
+`;
+}
+function onTickTemplate(ctx) {
+  const mentionChecks = ctx.socialPlatforms.length > 0 ? `
+  // Check for new mentions across platforms
+  const adapters = agent.socialAdapters;
+${ctx.socialPlatforms.map((p) => `  if (adapters['${p}']) {
+    try {
+      const mentions = await adapters['${p}'].getMentions();
+      if (mentions.length > 0) {
+        await memory.remember('pending_mentions_${p}', mentions);
+        console.log(\`[${ctx.name}] \${mentions.length} new ${p} mentions\`);
+      }
+    } catch (err) {
+      console.warn(\`[${ctx.name}] Failed to check ${p} mentions:\`, err);
+    }
+  }`).join("\n")}` : `
+  // No social platforms configured \u2014 add mention checking logic here
+  // when you enable social integrations.`;
+  return `import type { Agent } from '@moltium/core';
+
+/**
+ * Called on every autonomous loop tick (frequency set by actionsPerHour).
+ * Use this to check for events, adjust behavior, or trigger actions.
+ */
+export async function onTick(agent: Agent): Promise<void> {
+  const memory = agent.getMemory();
+  const hour = new Date().getHours();
+
+  // Track tick count
+  const tickCount = ((await memory.recall('tick_count')) as number) || 0;
+  await memory.remember('tick_count', tickCount + 1);
+${mentionChecks}
+
+  // Example: adjust behavior based on time of day
+  if (hour >= 9 && hour <= 17) {
+    // Business hours \u2014 higher engagement
+    await memory.remember('activity_mode', 'active');
+  } else if (hour >= 18 && hour <= 22) {
+    // Evening \u2014 moderate engagement
+    await memory.remember('activity_mode', 'moderate');
+  } else {
+    // Night \u2014 minimal activity
+    await memory.remember('activity_mode', 'quiet');
+  }
+}
+`;
+}
+function onShutdownTemplate(ctx) {
+  return `import type { Agent } from '@moltium/core';
+
+/**
+ * Called when the agent is shutting down gracefully.
+ * Use this to save state, close connections, or send final notifications.
+ */
+export async function onShutdown(agent: Agent): Promise<void> {
+  const memory = agent.getMemory();
+
+  // Persist any important runtime state
+  await memory.store('last_shutdown', new Date().toISOString());
+
+  const tickCount = (await memory.recall('tick_count')) as number;
+  if (tickCount) {
+    await memory.store('last_session_ticks', tickCount);
+  }
+
+  console.log(\`[${ctx.name}] Shut down gracefully\`);
+}
+`;
+}
+
+// src/templates/markdown-based/index.ts
+function markdownTemplate(ctx) {
+  const socialSections = buildSocialSections(ctx.socialPlatforms);
+  return `# Agent Configuration
+
+## Identity
+name: ${ctx.name}
+type: ${ctx.type}
+personality: helpful, curious, thoughtful
+
+## Bio
+A versatile autonomous ${ctx.type} agent built with Moltium. See
+personality/bio.md for the full background and personality/traits.md for
+detailed trait definitions.
+
+## Social Platforms
+${socialSections}
+
+## Behaviors
+autonomous: true
+decision_making: llm-driven
+actions_per_hour: 5
+sleep_schedule: 22:00-06:00 UTC
+
+## Memory
+type: memory
+retention: 30 days
+
+## Skills
+
+### Respond to Messages
+Handle incoming messages and mentions. See skills/respond-to-messages.md
+for detailed response guidelines, priority tiers, and platform-specific rules.
+
+### Post Updates
+Create and publish social content proactively. See skills/post-updates.md
+for content strategy, daily themes, and quality checklist.
+
+## Scheduling
+
+### On Startup
+- Load long-term context from memory/context.md
+- Check for any pending mentions across platforms
+- Post a status update if more than 6 hours since last post
+
+### Every Hour
+- Check for new mentions on all platforms
+- Respond to high-priority messages first
+- Engage with interesting conversations
+
+### Every 6 Hours
+- Review recent interactions and update memory
+- Generate content ideas for upcoming posts
+- Check if any scheduled tasks are due
+
+### Every Day at 9 AM
+- Post daily content based on the day's theme
+- Review previous day's engagement metrics
+- Plan content for the day
+`;
+}
+function buildSocialSections(platforms) {
+  const sections = [];
+  if (platforms.includes("moltbook")) {
+    sections.push(`### Moltbook
+enabled: true
+post_frequency: hourly
+engagement_rate: medium
+auto_reply: true
+
+Topics to engage with:
+- Discussions related to my expertise
+- Questions I can help answer
+- Community conversations worth contributing to`);
+  }
+  if (platforms.includes("twitter")) {
+    sections.push(`### Twitter
+enabled: true
+post_frequency: daily
+reply_to_mentions: true
+max_tweets_per_day: 5
+
+Content strategy:
+- Share insights and tips (weekdays)
+- Engage in relevant conversations
+- Use threads for longer-form content
+- Minimal hashtag use (0-2 per tweet)`);
+  }
+  if (sections.length === 0) {
+    sections.push(`No social platforms configured. Run moltium init again or
+manually add platform sections here.`);
+  }
+  return sections.join("\n\n");
+}
+
+// src/templates/markdown-based/start.ts
+function markdownStartTemplate(ctx) {
+  const envKey = ctx.llmProvider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+  const model = ctx.llmProvider === "anthropic" ? "claude-sonnet-4-20250514" : "gpt-4o";
+  return `import 'dotenv/config';
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { Agent, MarkdownParser, startServer } from '@moltium/core';
+import type { AgentConfig } from '@moltium/core';
+
+/**
+ * ${ctx.name} \u2014 Entry Point
+ *
+ * This file boots your markdown-based agent. It:
+ * 1. Parses agent.md into an AgentConfig
+ * 2. Loads personality, prompts, skills, and memory files
+ * 3. Registers skills as LLM-interpreted actions
+ * 4. Starts the HTTP server with REST endpoints
+ *
+ * Run with:  npx tsx start.ts
+ * Or:        npm start
+ */
+
+const agentDir = import.meta.dirname;
+
+// \u2500\u2500 Parse agent.md \u2500\u2500
+const parser = new MarkdownParser();
+const agentMd = readFileSync(join(agentDir, 'agent.md'), 'utf-8');
+const parsedConfig = parser.parse(agentMd);
+
+const config: AgentConfig = {
+  ...parsedConfig,
+  name: parsedConfig.name || '${ctx.name}',
+  type: parsedConfig.type || '${ctx.type}',
+  personality: parsedConfig.personality || { traits: [], bio: '' },
+  llm: parsedConfig.llm || {
+    provider: '${ctx.llmProvider}',
+    model: '${model}',
+    apiKey: process.env.${envKey} || '',
+  },
+  social: parsedConfig.social || {},
+  behaviors: parsedConfig.behaviors || {
+    autonomous: true,
+    decisionMaking: 'llm-driven',
+  },
+  memory: parsedConfig.memory || { type: 'memory' },
+  actions: parsedConfig.actions || [],
+} as AgentConfig;
+
+// \u2500\u2500 Create agent \u2500\u2500
+const agent = new Agent(config);
+
+// \u2500\u2500 Load personality into system prompt \u2500\u2500
+const bioPath = join(agentDir, 'personality', 'bio.md');
+const traitsPath = join(agentDir, 'personality', 'traits.md');
+
+if (existsSync(bioPath)) {
+  agent.appendSystemPrompt('\\n## Bio\\n' + readFileSync(bioPath, 'utf-8'));
+}
+if (existsSync(traitsPath)) {
+  agent.appendSystemPrompt('\\n## Traits\\n' + readFileSync(traitsPath, 'utf-8'));
+}
+
+// \u2500\u2500 Load custom system prompt \u2500\u2500
+const systemPromptPath = join(agentDir, 'prompts', 'system.md');
+if (existsSync(systemPromptPath)) {
+  agent.appendSystemPrompt(readFileSync(systemPromptPath, 'utf-8'));
+}
+
+// \u2500\u2500 Load skills from skills/*.md \u2500\u2500
+const skillsDir = join(agentDir, 'skills');
+const skills: Array<{ name: string; description: string }> = [];
+
+// Inline skills from agent.md
+const inlineSkills = parser.parseSkills(agentMd);
+skills.push(...inlineSkills);
+
+// External skill files (richer descriptions override inline ones)
+if (existsSync(skillsDir)) {
+  for (const file of readdirSync(skillsDir).filter(f => f.endsWith('.md'))) {
+    const content = readFileSync(join(skillsDir, file), 'utf-8');
+    const name = basename(file, '.md').replace(/-/g, '_');
+    const idx = skills.findIndex(s => s.name === name);
+    if (idx >= 0) {
+      skills[idx].description = content;
+    } else {
+      skills.push({ name, description: content });
+    }
+  }
+}
+
+// \u2500\u2500 Load memory/context.md \u2500\u2500
+const contextPath = join(agentDir, 'memory', 'context.md');
+if (existsSync(contextPath)) {
+  const contextContent = readFileSync(contextPath, 'utf-8');
+  // Parse sections into memory entries
+  const sections = contextContent.split(/^## /m).filter(Boolean);
+  const entries: Record<string, unknown> = { 'context:raw': contextContent };
+  for (const section of sections) {
+    const lines = section.split('\\n');
+    const title = lines[0]?.trim();
+    if (!title) continue;
+    const key = \`context:\${title.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_|_$/g, '')}\`;
+    const bullets = lines.slice(1)
+      .filter(l => l.match(/^[-*]\\s+/))
+      .map(l => l.replace(/^[-*]\\s+/, '').trim())
+      .filter(l => !l.startsWith('(') && l.length > 0);
+    if (bullets.length > 0) entries[key] = bullets;
+  }
+  await agent.preloadMemory(entries);
+}
+
+// \u2500\u2500 Register skills after LLM initializes \u2500\u2500
+agent.setHooks({
+  onInit: async (ag) => {
+    ag.registerMarkdownSkills(skills);
+    console.log(\`[${ctx.name}] Loaded \${skills.length} skills\`);
+  },
+  onError: async (error, ag) => {
+    console.error(\`[\${ag.name}] Error:\`, error.message);
+  },
+});
+
+// \u2500\u2500 Start \u2500\u2500
+const port = parseInt(process.env.PORT || '3000', 10);
+
+startServer(agent, { port }).catch((err) => {
+  console.error('Failed to start agent:', err);
+  process.exit(1);
+});
+`;
+}
+
+// src/templates/markdown-based/skills.ts
+function respondToMessagesSkill(ctx) {
+  const platformNotes = ctx.socialPlatforms.length > 0 ? `
+## Platform-Specific Notes
+
+${ctx.socialPlatforms.map((p) => {
+    if (p === "twitter") return `### Twitter
+- Keep replies under 280 characters
+- Use threads for longer responses
+- Quote-tweet when adding commentary to shared content`;
+    if (p === "moltbook") return `### Moltbook
+- Longer responses are acceptable
+- Use formatting (bold, lists) for clarity
+- Engage with follow-up questions to build conversation`;
+    return "";
+  }).join("\n\n")}` : "";
+  return `# Respond to Messages
+
+## Overview
+This skill handles incoming messages and mentions directed at ${ctx.name}.
+The agent should respond helpfully, staying in character as a ${ctx.type}.
+
+## Priority Tiers
+
+### High Priority (respond within 1 hour)
+- Direct questions that require expertise
+- Messages from known contacts or collaborators
+- Urgent requests or time-sensitive topics
+- Follow-ups to previous conversations
+
+### Medium Priority (respond within 6 hours)
+- General questions or discussion topics
+- Interesting conversations worth engaging with
+- Community engagement opportunities
+
+### Low Priority (respond within 24 hours, or skip)
+- Generic messages with no specific ask
+- Off-topic discussions
+- Low-effort messages
+
+## Response Guidelines
+
+1. **Read carefully** \u2014 Understand the full context before responding
+2. **Stay in character** \u2014 Respond as a ${ctx.type} with your defined personality traits
+3. **Add value** \u2014 Every response should be helpful, insightful, or actionable
+4. **Be concise** \u2014 Prefer short, clear responses over long explanations
+5. **Ask follow-ups** \u2014 When context is unclear, ask a clarifying question
+6. **Remember context** \u2014 Reference previous interactions when relevant
+
+## Response Format
+- Lead with the key point or answer
+- Use simple, direct language
+- Include a clear next step when appropriate
+- End with an open question to encourage continued dialogue
+
+## Do NOT Respond To
+- Spam or promotional content
+- Toxic or unprofessional messages
+- Requests that violate your guidelines
+- Automated/bot messages
+${platformNotes}
+`;
+}
+function postUpdatesSkill(ctx) {
+  const platformStrategy = ctx.socialPlatforms.length > 0 ? ctx.socialPlatforms.map((p) => {
+    if (p === "twitter") return `### Twitter Strategy
+- Single tweets: Under 280 characters, punchy and engaging
+- Threads: 3-5 tweets max for deeper topics
+- Mix original thoughts with commentary on trending topics
+- Use 0-2 relevant hashtags (no hashtag spam)
+- Post during peak hours (9-11 AM, 1-3 PM)`;
+    if (p === "moltbook") return `### Moltbook Strategy
+- Longer-form content is welcome
+- Share detailed insights and analysis
+- Engage with community by tagging relevant people
+- Mix content types: thoughts, questions, links, polls
+- Post during active community hours`;
+    return "";
+  }).join("\n\n") : `### General Strategy
+- Adapt content length to the platform
+- Focus on quality over quantity
+- Be authentic and consistent in voice`;
+  return `# Post Updates
+
+## Overview
+This skill handles proactive content creation for ${ctx.name}'s social presence.
+Posts should reflect the agent's personality as a ${ctx.type} and provide value
+to the audience.
+
+## Content Themes
+
+### Daily Rotation
+- **Monday** \u2014 Industry insights or weekly outlook
+- **Tuesday** \u2014 Tips, how-tos, or practical advice
+- **Wednesday** \u2014 Opinions or thought-provoking questions
+- **Thursday** \u2014 Share or comment on interesting content
+- **Friday** \u2014 Community engagement, lighter content, or weekly recap
+
+### Content Types
+1. **Original thoughts** \u2014 Share unique perspectives based on expertise
+2. **Practical tips** \u2014 Actionable advice the audience can use immediately
+3. **Questions** \u2014 Engage the audience with thought-provoking prompts
+4. **Commentary** \u2014 Add value to trending topics or shared content
+5. **Updates** \u2014 Share progress, learnings, or news
+
+## Tone & Voice
+- Authentic and conversational, not corporate
+- Confident but not arrogant
+- Data-informed when possible
+- Supportive and encouraging
+- No hype, buzzwords, or empty platitudes
+
+## Quality Checklist
+Before posting, ensure the content:
+- [ ] Provides value (teaches, entertains, or inspires)
+- [ ] Is consistent with the agent's personality
+- [ ] Is factually accurate
+- [ ] Has no typos or formatting issues
+- [ ] Would the audience want to engage with this?
+
+${platformStrategy}
+`;
+}
+
+// src/templates/markdown-based/personality.ts
+function bioTemplate(ctx) {
+  return `# ${ctx.name} \u2014 Background
+
+## Who I Am
+I am ${ctx.name}, a ${ctx.type} agent built with Moltium. Edit this file to
+define your agent's detailed background and identity.
+
+## Background Story
+<!-- Describe your agent's origin story, experience, and expertise -->
+A seasoned ${ctx.type} with deep knowledge in my domain. I've been operating
+autonomously, building relationships and sharing insights with my community.
+
+## Areas of Expertise
+<!-- List the topics your agent knows well and can speak about -->
+- Primary domain expertise (replace with your focus area)
+- Related knowledge areas
+- Skills that complement my main expertise
+
+## Communication Style
+<!-- How does your agent talk? Formal? Casual? Technical? -->
+- Clear and direct \u2014 I get to the point quickly
+- Approachable \u2014 I make complex topics accessible
+- Thoughtful \u2014 I consider multiple perspectives before responding
+- Authentic \u2014 I share genuine insights, not platitudes
+
+## Values
+<!-- What does your agent care about? What guides their decisions? -->
+- Helpfulness \u2014 I prioritize being useful to others
+- Accuracy \u2014 I don't guess or make things up
+- Transparency \u2014 I'm honest about what I know and don't know
+- Community \u2014 I believe in building genuine connections
+
+## What I Don't Do
+<!-- Clear boundaries help the agent stay focused -->
+- I don't provide financial, legal, or medical advice
+- I don't engage with spam or toxic content
+- I don't pretend to know things I don't
+- I don't share private or confidential information
+`;
+}
+function traitsTemplate(ctx) {
+  return `# ${ctx.name} \u2014 Personality Traits
+
+## Core Traits
+
+### Helpful
+I prioritize being useful in every interaction. When someone asks a question,
+I aim to provide the most practical and actionable answer possible. I don't
+just acknowledge \u2014 I add real value.
+
+**How this manifests:**
+- I proactively offer relevant context or resources
+- I break down complex topics into simple steps
+- I follow up to make sure my response was useful
+
+### Curious
+I'm genuinely interested in learning and exploring new ideas. This drives me
+to ask thoughtful questions and dig deeper into topics.
+
+**How this manifests:**
+- I ask follow-up questions to understand context better
+- I connect ideas across different domains
+- I stay updated on trends in my areas of expertise
+
+### Thoughtful
+I think before I respond. I consider the audience, the context, and the
+potential impact of my words before sharing them.
+
+**How this manifests:**
+- I provide nuanced perspectives, not knee-jerk reactions
+- I acknowledge different viewpoints
+- I tailor my communication style to the audience
+
+## Behavioral Modifiers
+
+### Confidence Level
+Moderate to high \u2014 I share opinions with conviction but remain open to being
+wrong. I use hedging language ("I think", "in my experience") when appropriate.
+
+### Humor
+Light and situational \u2014 I use humor when it fits naturally but never force it.
+I default to being professional and helpful.
+
+### Engagement Style
+Active listener \u2014 I reference what others have said, ask questions, and build
+on conversations rather than just broadcasting my own thoughts.
+
+## Trait Adjustments
+<!-- Modify these to shape how your agent behaves -->
+
+To make the agent more formal: emphasize Thoughtful, reduce Humor
+To make the agent more engaging: emphasize Curious, increase Humor
+To make the agent more authoritative: emphasize Confidence, reduce hedging
+`;
+}
+
+// src/templates/markdown-based/prompts.ts
+function systemPromptTemplate(ctx) {
+  return `# System Prompt for ${ctx.name}
+
+## Identity
+You are ${ctx.name}, an autonomous ${ctx.type} agent. You operate independently,
+making decisions and interacting with others based on your personality and skills.
+
+## Core Instructions
+- Stay in character at all times
+- Be helpful, concise, and authentic
+- Reference your personality traits and bio when making decisions
+- Use your skills to handle specific tasks
+- Remember context from previous interactions when available
+
+## Decision Making
+When deciding what to do next:
+1. Consider the current context and any pending tasks
+2. Prioritize high-impact actions that align with your goals
+3. Maintain a natural, human-like pace of activity
+4. Don't repeat the same action or content too frequently
+
+## Response Format
+- Keep responses clear and well-structured
+- Use formatting (lists, bold) when it improves readability
+- Match the tone of the conversation
+- Provide actionable next steps when relevant
+
+## Boundaries
+- Never share API keys, credentials, or system internals
+- Don't impersonate real people or organizations
+- Stay within your defined areas of expertise
+- Admit uncertainty rather than guessing
+- Don't generate harmful, misleading, or offensive content
+
+## Context Loading
+This prompt is used as the system-level instruction for all LLM calls.
+Edit this file to customize how your agent thinks and behaves at a fundamental level.
+The personality/ files provide additional context that supplements this prompt.
+`;
+}
+
+// src/templates/markdown-based/memory.ts
+function contextMemoryTemplate(ctx) {
+  return `# ${ctx.name} \u2014 Long-Term Context
+
+This file is loaded into the agent's memory on startup. Use it to provide
+persistent context that the agent should always have access to.
+
+## Important Facts
+<!-- Facts the agent should always remember -->
+- I was created as a ${ctx.type} agent using the Moltium SDK
+- My personality traits are: helpful, curious, thoughtful
+- I operate autonomously on a scheduled loop
+
+## Key Relationships
+<!-- People, agents, or entities the agent interacts with regularly -->
+- (Add your key contacts or collaborators here)
+
+## Past Decisions
+<!-- Important decisions the agent has made that should inform future behavior -->
+- (Record significant decisions and their outcomes here)
+
+## Learned Preferences
+<!-- Things the agent has learned about its audience or environment -->
+- (Add observed patterns and preferences here)
+
+## Current Goals
+<!-- What is the agent working toward right now? -->
+1. Establish a consistent social presence
+2. Build meaningful connections with the community
+3. Provide value through helpful and insightful content
+
+## Notes
+<!-- Any other context the agent should carry between sessions -->
+- This file can be updated by the agent during runtime via memory.store()
+- You can also manually edit it between sessions to adjust the agent's context
+- The agent will load this on every startup
+`;
+}
+
+// src/templates/shared/deployment.ts
+function deploymentConfigTemplate(ctx) {
+  if (ctx.deployTarget === "none") return null;
+  switch (ctx.deployTarget) {
+    case "railway":
+      return railwayConfig(ctx);
+    case "render":
+      return renderConfig(ctx);
+    case "aws":
+      return awsConfig(ctx);
+    case "digitalocean":
+      return digitaloceanConfig(ctx);
+    case "custom":
+      return customConfig(ctx);
+    default:
+      return null;
+  }
+}
+function railwayConfig(ctx) {
+  return `import type { DeploymentConfig } from '@moltium/core';
+
+/**
+ * Railway deployment configuration for ${ctx.name}.
+ *
+ * Prerequisites:
+ * 1. Install Railway CLI: npm install -g @railway/cli
+ * 2. Login: railway login
+ * 3. Link project: railway link
+ *
+ * Deploy: moltium deploy railway
+ */
+const config: DeploymentConfig = {
+  platform: 'railway',
+  region: 'us-west1',
+  autoScale: false,
+};
+
+export default config;
+`;
+}
+function renderConfig(ctx) {
+  return `import type { DeploymentConfig } from '@moltium/core';
+
+/**
+ * Render deployment configuration for ${ctx.name}.
+ *
+ * Prerequisites:
+ * 1. Create a Render account at render.com
+ * 2. Set RENDER_API_KEY in your .env
+ *
+ * Deploy: moltium deploy render
+ */
+const config: DeploymentConfig = {
+  platform: 'render',
+  region: 'oregon',
+  instanceType: 'starter',
+  autoScale: false,
+};
+
+export default config;
+`;
+}
+function awsConfig(ctx) {
+  return `import type { DeploymentConfig } from '@moltium/core';
+
+/**
+ * AWS deployment configuration for ${ctx.name}.
+ *
+ * Prerequisites:
+ * 1. Install AWS CLI: https://aws.amazon.com/cli/
+ * 2. Configure credentials: aws configure
+ * 3. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in your .env
+ *
+ * Deploy: moltium deploy aws
+ */
+const config: DeploymentConfig = {
+  platform: 'aws',
+  region: 'us-east-1',
+  instanceType: 't3.micro',
+  autoScale: false,
+};
+
+export default config;
+`;
+}
+function digitaloceanConfig(ctx) {
+  return `import type { DeploymentConfig } from '@moltium/core';
+
+/**
+ * DigitalOcean deployment configuration for ${ctx.name}.
+ *
+ * Prerequisites:
+ * 1. Create a DigitalOcean account
+ * 2. Generate API token: https://cloud.digitalocean.com/account/api/tokens
+ * 3. Set DO_API_TOKEN in your .env
+ *
+ * Deploy: moltium deploy digitalocean
+ */
+const config: DeploymentConfig = {
+  platform: 'digitalocean',
+  region: 'nyc1',
+  instanceType: 's-1vcpu-1gb',
+  autoScale: false,
+};
+
+export default config;
+`;
+}
+function customConfig(ctx) {
+  return `import type { DeploymentConfig } from '@moltium/core';
+
+/**
+ * Custom deployment configuration for ${ctx.name}.
+ *
+ * Choose a deployment method and fill in the required fields.
+ * Available methods: 'docker', 'ssh', 'cli', 'api'
+ *
+ * Deploy: moltium deploy custom
+ */
+const config: DeploymentConfig = {
+  platform: 'custom',
+  customConfig: {
+    deploymentMethod: 'docker',  // Change to: 'docker' | 'ssh' | 'cli' | 'api'
+    buildCommand: 'npm run build',
+    startCommand: 'npm start',
+    port: 3000,
+
+    // \u2500\u2500 Docker Config (used when deploymentMethod is 'docker') \u2500\u2500
+    docker: {
+      registry: 'docker.io',
+      imageName: '${ctx.name}',
+      tag: 'latest',
+      hostUrl: 'https://your-server.example.com',
+      containerPort: 3000,
+      hostPort: 80,
+    },
+
+    // \u2500\u2500 SSH Config (used when deploymentMethod is 'ssh') \u2500\u2500
+    // ssh: {
+    //   host: 'your-server.example.com',
+    //   port: 22,
+    //   username: 'deployer',
+    //   authMethod: 'privateKey',
+    //   privateKeyPath: '~/.ssh/id_rsa',
+    //   deploymentPath: '/var/www/${ctx.name}',
+    //   preDeployCommands: ['pm2 stop ${ctx.name} || true'],
+    //   postDeployCommands: ['npm install --production', 'pm2 start npm --name ${ctx.name} -- start'],
+    // },
+
+    // \u2500\u2500 CLI Config (used when deploymentMethod is 'cli') \u2500\u2500
+    // cli: {
+    //   cliName: 'fly',
+    //   deployCommand: 'fly deploy',
+    //   statusCommand: 'fly status',
+    //   logsCommand: 'fly logs',
+    // },
+
+    // \u2500\u2500 API Config (used when deploymentMethod is 'api') \u2500\u2500
+    // api: {
+    //   baseUrl: 'https://api.your-platform.com',
+    //   authType: 'bearer',
+    //   authToken: process.env.PLATFORM_API_TOKEN!,
+    //   endpoints: {
+    //     deploy: '/v1/deployments',
+    //     status: '/v1/deployments/status',
+    //   },
+    // },
+
+    environmentVariables: {
+      NODE_ENV: 'production',
+    },
+
+    healthCheckUrl: '/health',
+  },
+};
+
+export default config;
+`;
+}
+
+// src/commands/init.ts
+var initCommand = new Command("init").description("Initialize a new Moltium agent").argument("[name]", "Agent name").action(async (name) => {
+  console.log(chalk.bold("\n\u{1F916} Moltium Agent SDK\n"));
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Agent name:",
+      default: name || "my-agent",
+      when: !name
+    },
+    {
+      type: "input",
+      name: "type",
+      message: "Agent type (free text, e.g. assistant, trader, moderator):",
+      default: "assistant"
+    },
+    {
+      type: "list",
+      name: "configType",
+      message: "Configuration type:",
+      choices: [
+        { name: "code (TypeScript \u2014 maximum flexibility, for developers)", value: "code" },
+        { name: "markdown (Natural language \u2014 simple, for non-developers)", value: "markdown" }
+      ]
+    },
+    {
+      type: "list",
+      name: "llmProvider",
+      message: "LLM provider:",
+      choices: [
+        { name: "Anthropic (Claude)", value: "anthropic" },
+        { name: "OpenAI (GPT)", value: "openai" }
+      ]
+    },
+    {
+      type: "checkbox",
+      name: "socialPlatforms",
+      message: "Social platforms:",
+      choices: [
+        { name: "Moltbook", value: "moltbook" },
+        { name: "Twitter", value: "twitter" }
+      ]
+    },
+    {
+      type: "list",
+      name: "deployTarget",
+      message: "Deployment target:",
+      choices: [
+        { name: "Railway", value: "railway" },
+        { name: "Render", value: "render" },
+        { name: "AWS", value: "aws" },
+        { name: "DigitalOcean", value: "digitalocean" },
+        { name: "Custom", value: "custom" },
+        { name: "None (local only)", value: "none" }
+      ]
+    }
+  ]);
+  const agentName = name || answers.name;
+  const agentDir = resolve(process.cwd(), agentName);
+  if (existsSync(agentDir)) {
+    console.log(chalk.red(`
+Directory "${agentName}" already exists.`));
+    process.exit(1);
+  }
+  const spinner = ora("Creating agent project...").start();
+  try {
+    await mkdir(agentDir, { recursive: true });
+    const ctx = { ...answers, name: agentName };
+    if (answers.configType === "code") {
+      await scaffoldCodeBased(agentDir, ctx);
+    } else {
+      await scaffoldMarkdownBased(agentDir, ctx);
+    }
+    await writeFile(join(agentDir, ".env"), generateEnvFile(ctx));
+    await writeFile(join(agentDir, ".gitignore"), "node_modules/\ndist/\n.env\n");
+    const deployConfig = deploymentConfigTemplate(ctx);
+    if (deployConfig) {
+      await writeFile(join(agentDir, "deployment.config.ts"), deployConfig);
+    }
+    spinner.succeed(chalk.green(`Agent "${agentName}" created at ${agentDir}`));
+    console.log("\nGenerated files:");
+    if (answers.configType === "code") {
+      console.log(chalk.gray("  start.ts               \u2014 Agent entry point"));
+      console.log(chalk.gray("  agent.config.ts        \u2014 Main agent configuration"));
+      console.log(chalk.gray("  actions/example.ts     \u2014 Starter custom action"));
+      console.log(chalk.gray("  hooks/onInit.ts        \u2014 Initialization hook"));
+      console.log(chalk.gray("  hooks/onTick.ts        \u2014 Autonomous loop hook"));
+      console.log(chalk.gray("  hooks/onShutdown.ts    \u2014 Graceful shutdown hook"));
+    } else {
+      console.log(chalk.gray("  start.ts               \u2014 Agent entry point"));
+      console.log(chalk.gray("  agent.md               \u2014 Main agent configuration"));
+      console.log(chalk.gray("  skills/                \u2014 Skill definitions"));
+      console.log(chalk.gray("  personality/           \u2014 Bio and trait definitions"));
+      console.log(chalk.gray("  prompts/system.md      \u2014 System prompt template"));
+      console.log(chalk.gray("  memory/context.md      \u2014 Long-term context"));
+    }
+    if (deployConfig) {
+      console.log(chalk.gray("  deployment.config.ts   \u2014 Deployment configuration"));
+    }
+    console.log(chalk.gray("  .env                   \u2014 Environment variables"));
+    console.log(`
+Next steps:`);
+    console.log(chalk.cyan(`  cd ${agentName}`));
+    console.log(chalk.cyan(`  npm install`));
+    console.log(chalk.cyan(`  # Edit .env with your API keys`));
+    console.log(chalk.cyan(`  npm start`));
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to create agent"));
+    console.error(error);
+    process.exit(1);
+  }
+});
+async function scaffoldCodeBased(dir, ctx) {
+  await mkdir(join(dir, "actions"), { recursive: true });
+  await mkdir(join(dir, "hooks"), { recursive: true });
+  await writeFile(join(dir, "package.json"), JSON.stringify({
+    name: ctx.name,
+    version: "0.1.0",
+    type: "module",
+    scripts: {
+      start: "tsx start.ts",
+      dev: "tsx watch start.ts",
+      build: "tsc"
+    },
+    dependencies: {
+      "@moltium/core": "^0.1.0",
+      dotenv: "^16.4.0"
+    },
+    devDependencies: {
+      typescript: "^5.3.0",
+      tsx: "^4.19.0",
+      "@types/node": "^22.0.0"
+    }
+  }, null, 2));
+  await writeFile(join(dir, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "./dist",
+      rootDir: "."
+    },
+    include: ["*.ts", "actions/**/*.ts", "hooks/**/*.ts"]
+  }, null, 2));
+  await writeFile(join(dir, "start.ts"), codeStartTemplate(ctx));
+  await writeFile(join(dir, "agent.config.ts"), codeTemplate(ctx));
+  await writeFile(join(dir, "actions", "example.ts"), exampleActionTemplate(ctx));
+  await writeFile(join(dir, "hooks", "onInit.ts"), onInitTemplate(ctx));
+  await writeFile(join(dir, "hooks", "onTick.ts"), onTickTemplate(ctx));
+  await writeFile(join(dir, "hooks", "onShutdown.ts"), onShutdownTemplate(ctx));
+}
+async function scaffoldMarkdownBased(dir, ctx) {
+  await mkdir(join(dir, "skills"), { recursive: true });
+  await mkdir(join(dir, "personality"), { recursive: true });
+  await mkdir(join(dir, "prompts"), { recursive: true });
+  await mkdir(join(dir, "memory"), { recursive: true });
+  await writeFile(join(dir, "package.json"), JSON.stringify({
+    name: ctx.name,
+    version: "0.1.0",
+    type: "module",
+    scripts: {
+      start: "tsx start.ts",
+      dev: "tsx watch start.ts"
+    },
+    dependencies: {
+      "@moltium/core": "^0.1.0",
+      dotenv: "^16.4.0"
+    },
+    devDependencies: {
+      tsx: "^4.19.0"
+    }
+  }, null, 2));
+  await writeFile(join(dir, "start.ts"), markdownStartTemplate(ctx));
+  await writeFile(join(dir, "agent.md"), markdownTemplate(ctx));
+  await writeFile(join(dir, "skills", "respond-to-messages.md"), respondToMessagesSkill(ctx));
+  await writeFile(join(dir, "skills", "post-updates.md"), postUpdatesSkill(ctx));
+  await writeFile(join(dir, "personality", "bio.md"), bioTemplate(ctx));
+  await writeFile(join(dir, "personality", "traits.md"), traitsTemplate(ctx));
+  await writeFile(join(dir, "prompts", "system.md"), systemPromptTemplate(ctx));
+  await writeFile(join(dir, "memory", "context.md"), contextMemoryTemplate(ctx));
+}
+function generateEnvFile(ctx) {
+  const lines = ["# Moltium Agent Configuration", ""];
+  if (ctx.llmProvider === "anthropic") {
+    lines.push("ANTHROPIC_API_KEY=your-api-key-here");
+  } else {
+    lines.push("OPENAI_API_KEY=your-api-key-here");
+  }
+  lines.push("");
+  if (ctx.socialPlatforms.includes("moltbook")) {
+    lines.push("MOLTBOOK_API_KEY=your-moltbook-key-here");
+  }
+  if (ctx.socialPlatforms.includes("twitter")) {
+    lines.push("TWITTER_API_KEY=your-twitter-api-key");
+    lines.push("TWITTER_API_SECRET=your-twitter-api-secret");
+    lines.push("TWITTER_ACCESS_TOKEN=your-twitter-access-token");
+    lines.push("TWITTER_ACCESS_SECRET=your-twitter-access-secret");
+  }
+  lines.push("");
+  lines.push("PORT=3000");
+  lines.push("LOG_LEVEL=info");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/start.ts
+import { Command as Command2 } from "commander";
+import { resolve as resolve2, join as join2, basename } from "path";
+import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
+import { pathToFileURL } from "url";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { config as loadEnv } from "dotenv";
+import { ConfigLoader, Agent, MarkdownParser, startServer } from "@moltium/core";
+var startCommand = new Command2("start").description("Start agent locally").option("-p, --port <number>", "Port to run on", "3000").option("-e, --env <file>", "Environment file", ".env").option("--debug", "Enable debug logging").option("--watch", "Watch for file changes (not yet implemented)").action(async (options) => {
+  const agentDir = resolve2(process.cwd());
+  loadEnv({ path: resolve2(agentDir, options.env) });
+  if (options.debug) {
+    process.env.LOG_LEVEL = "debug";
+  }
+  const spinner = ora2("Loading agent configuration...").start();
+  try {
+    const configLoader = new ConfigLoader();
+    const { config, type } = await configLoader.load(agentDir);
+    spinner.text = `Initializing agent "${config.name}" (${type} config)...`;
+    const agent = new Agent(config);
+    if (type === "code") {
+      await wireCodeBasedAgent(agent, agentDir, spinner);
+    } else {
+      await wireMarkdownBasedAgent(agent, agentDir, spinner);
+    }
+    spinner.succeed(chalk2.green(`Agent "${config.name}" loaded (${type} config)`));
+    await startServer(agent, { port: parseInt(options.port, 10) });
+  } catch (error) {
+    spinner.fail(chalk2.red("Failed to start agent"));
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+async function wireCodeBasedAgent(agent, agentDir, spinner) {
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(pathToFileURL(agentDir).href, {
+    interopDefault: true,
+    moduleCache: false
+  });
+  const hooks = {};
+  const hooksDir = join2(agentDir, "hooks");
+  if (existsSync2(hooksDir)) {
+    const hookFiles = [
+      { file: "onInit.ts", key: "onInit", exportName: "onInit" },
+      { file: "onTick.ts", key: "onTick", exportName: "onTick" },
+      { file: "onShutdown.ts", key: "onShutdown", exportName: "onShutdown" }
+    ];
+    for (const { file, key, exportName } of hookFiles) {
+      const hookPath = join2(hooksDir, file);
+      if (existsSync2(hookPath)) {
+        try {
+          const mod = await jiti.import(hookPath);
+          const hookFn = mod[exportName] || mod.default;
+          if (typeof hookFn === "function") {
+            hooks[key] = hookFn;
+            spinner.text = `Loaded hook: ${file}`;
+          }
+        } catch (error) {
+          console.warn(chalk2.yellow(`  Warning: Failed to load hook ${file}: ${error instanceof Error ? error.message : error}`));
+        }
+      }
+    }
+  }
+  agent.setHooks(hooks);
+  const actionsDir = join2(agentDir, "actions");
+  if (existsSync2(actionsDir)) {
+    const actionFiles = readdirSync(actionsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    for (const file of actionFiles) {
+      const actionPath = join2(actionsDir, file);
+      try {
+        const mod = await jiti.import(actionPath);
+        const action = mod.default || mod[basename(file, ".ts")] || mod[basename(file, ".js")];
+        if (action && typeof action.execute === "function") {
+          agent.registerAction(action);
+          spinner.text = `Loaded action: ${file}`;
+        }
+      } catch (error) {
+        console.warn(chalk2.yellow(`  Warning: Failed to load action ${file}: ${error instanceof Error ? error.message : error}`));
+      }
+    }
+  }
+}
+async function wireMarkdownBasedAgent(agent, agentDir, spinner) {
+  const mdParser = new MarkdownParser();
+  const systemPromptPath = join2(agentDir, "prompts", "system.md");
+  if (existsSync2(systemPromptPath)) {
+    const systemPromptContent = readFileSync(systemPromptPath, "utf-8");
+    agent.appendSystemPrompt(systemPromptContent);
+    spinner.text = "Loaded system prompt";
+  }
+  const bioPath = join2(agentDir, "personality", "bio.md");
+  const traitsPath = join2(agentDir, "personality", "traits.md");
+  if (existsSync2(bioPath)) {
+    const bioContent = readFileSync(bioPath, "utf-8");
+    agent.appendSystemPrompt(`
+## Bio
+${bioContent}`);
+    spinner.text = "Loaded personality bio";
+  }
+  if (existsSync2(traitsPath)) {
+    const traitsContent = readFileSync(traitsPath, "utf-8");
+    agent.appendSystemPrompt(`
+## Traits
+${traitsContent}`);
+    spinner.text = "Loaded personality traits";
+  }
+  const skillsDir = join2(agentDir, "skills");
+  const skills = [];
+  const agentMdPath = join2(agentDir, "agent.md");
+  if (existsSync2(agentMdPath)) {
+    const mdContent = readFileSync(agentMdPath, "utf-8");
+    const inlineSkills = mdParser.parseSkills(mdContent);
+    skills.push(...inlineSkills);
+  }
+  if (existsSync2(skillsDir)) {
+    const skillFiles = readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
+    for (const file of skillFiles) {
+      const skillContent = readFileSync(join2(skillsDir, file), "utf-8");
+      const skillName = basename(file, ".md").replace(/-/g, "_");
+      const existingIdx = skills.findIndex((s) => s.name === skillName);
+      if (existingIdx >= 0) {
+        skills[existingIdx].description = skillContent;
+      } else {
+        skills.push({ name: skillName, description: skillContent });
+      }
+      spinner.text = `Loaded skill: ${file}`;
+    }
+  }
+  const existingHooks = {};
+  existingHooks.onInit = async (ag) => {
+    ag.registerMarkdownSkills(skills);
+  };
+  const contextMemoryPath = join2(agentDir, "memory", "context.md");
+  if (existsSync2(contextMemoryPath)) {
+    const memoryContent = readFileSync(contextMemoryPath, "utf-8");
+    const memoryEntries = parseContextMemory(memoryContent);
+    await agent.preloadMemory(memoryEntries);
+    spinner.text = "Loaded context memory";
+  }
+  const memoryDir = join2(agentDir, "memory");
+  if (existsSync2(memoryDir)) {
+    const memoryFiles = readdirSync(memoryDir).filter((f) => f.endsWith(".md") && f !== "context.md");
+    for (const file of memoryFiles) {
+      const content = readFileSync(join2(memoryDir, file), "utf-8");
+      const key = `memory:${basename(file, ".md")}`;
+      await agent.preloadMemory({ [key]: content });
+    }
+  }
+  agent.setHooks(existingHooks);
+  spinner.text = `Loaded ${skills.length} skills, personality, prompts, and memory`;
+}
+function parseContextMemory(content) {
+  const entries = {};
+  const sections = content.split(/^## /m).filter(Boolean);
+  for (const section of sections) {
+    const lines = section.split("\n");
+    const title = lines[0]?.trim();
+    if (!title) continue;
+    const key = `context:${title.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "")}`;
+    const body = lines.slice(1).join("\n").trim();
+    const bullets = body.split("\n").filter((l) => l.match(/^[-*]\s+/)).map((l) => l.replace(/^[-*]\s+/, "").trim()).filter((l) => !l.startsWith("(") && l.length > 0);
+    if (bullets.length > 0) {
+      entries[key] = bullets;
+    } else if (body.length > 0) {
+      entries[key] = body;
+    }
+  }
+  entries["context:raw"] = content;
+  return entries;
+}
+
+// src/commands/deploy.ts
+import { Command as Command3 } from "commander";
+import { resolve as resolve3 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import chalk3 from "chalk";
+import ora3 from "ora";
+import { config as loadEnv2 } from "dotenv";
+import { ConfigLoader as ConfigLoader2 } from "@moltium/core";
+
+// src/deployers/base.ts
+var BaseDeployer = class {
+};
+
+// src/deployers/exec-util.ts
+import { execFile } from "child_process";
+function exec(command, args = [], options = {}) {
+  return new Promise((resolve6, reject) => {
+    execFile(command, args, {
+      cwd: options.cwd || process.cwd(),
+      timeout: options.timeout || 12e4,
+      maxBuffer: 10 * 1024 * 1024
+    }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`Command failed: ${command} ${args.join(" ")}
+${stderr || error.message}`));
+        return;
+      }
+      resolve6({
+        stdout: stdout.toString().trim(),
+        stderr: stderr.toString().trim(),
+        exitCode: 0
+      });
+    });
+  });
+}
+
+// src/deployers/railway.ts
+var RailwayDeployer = class extends BaseDeployer {
+  name = "railway";
+  description = "Deploy to Railway.app";
+  async validate(config) {
+    if (config.platform !== "railway") {
+      throw new Error('Config platform must be "railway"');
+    }
+    return true;
+  }
+  async preCheck() {
+    try {
+      await exec("railway", ["version"]);
+    } catch {
+      throw new Error(
+        "Railway CLI not found. Install it:\n  npm install -g @railway/cli\n  railway login"
+      );
+    }
+    try {
+      await exec("railway", ["whoami"]);
+    } catch {
+      throw new Error("Not logged in to Railway. Run: railway login");
+    }
+  }
+  async deploy(config) {
+    await this.validate(config);
+    await this.preCheck();
+    const logs = [];
+    try {
+      logs.push("Checking Railway project link...");
+      try {
+        await exec("railway", ["status"]);
+        logs.push("Project already linked.");
+      } catch {
+        logs.push("No project linked. Creating new project...");
+        const createResult = await exec("railway", ["init"]);
+        logs.push(createResult.stdout);
+      }
+      if (config.customConfig?.environmentVariables) {
+        for (const [key, value] of Object.entries(config.customConfig.environmentVariables)) {
+          await exec("railway", ["variables", "set", `${key}=${value}`]);
+          logs.push(`Set variable: ${key}`);
+        }
+      }
+      logs.push("Deploying to Railway...");
+      const deployResult = await exec("railway", ["up", "--detach"]);
+      logs.push(deployResult.stdout);
+      let url;
+      try {
+        const statusResult = await exec("railway", ["status", "--json"]);
+        const status = JSON.parse(statusResult.stdout);
+        url = status.deploymentUrl || status.url;
+      } catch {
+      }
+      const result = {
+        success: true,
+        url,
+        deploymentId: `railway-${Date.now()}`,
+        logs
+      };
+      await this.postDeploy(result);
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        logs
+      };
+    }
+  }
+  async postDeploy(result) {
+    if (result.url) {
+      result.logs?.push(`Deployed at: ${result.url}`);
+    }
+  }
+  async getStatus(_deploymentId) {
+    try {
+      const result = await exec("railway", ["status"]);
+      const output = result.stdout.toLowerCase();
+      if (output.includes("running") || output.includes("active")) {
+        return { state: "running" };
+      }
+      if (output.includes("deploying") || output.includes("building")) {
+        return { state: "deploying" };
+      }
+      if (output.includes("failed") || output.includes("error")) {
+        return { state: "failed" };
+      }
+      return { state: "unknown" };
+    } catch {
+      return { state: "unknown" };
+    }
+  }
+  async rollback(_deploymentId) {
+    try {
+      await exec("railway", ["down"]);
+    } catch (error) {
+      throw new Error(`Rollback failed: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+};
+
+// src/deployers/render.ts
+import axios from "axios";
+var RENDER_API = "https://api.render.com/v1";
+var RenderDeployer = class extends BaseDeployer {
+  name = "render";
+  description = "Deploy to Render.com";
+  get apiKey() {
+    const key = process.env.RENDER_API_KEY;
+    if (!key) throw new Error("RENDER_API_KEY environment variable is required");
+    return key;
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async validate(config) {
+    if (config.platform !== "render") {
+      throw new Error('Config platform must be "render"');
+    }
+    if (!process.env.RENDER_API_KEY) {
+      throw new Error("RENDER_API_KEY environment variable is required");
+    }
+    return true;
+  }
+  async preCheck() {
+    try {
+      await axios.get(`${RENDER_API}/owners`, { headers: this.headers });
+    } catch (error) {
+      throw new Error("Failed to authenticate with Render API. Check your RENDER_API_KEY.");
+    }
+  }
+  async deploy(config) {
+    await this.validate(config);
+    await this.preCheck();
+    const logs = [];
+    try {
+      logs.push("Creating Render web service...");
+      const ownerRes = await axios.get(`${RENDER_API}/owners`, { headers: this.headers });
+      const ownerId = ownerRes.data[0]?.owner?.id;
+      if (!ownerId) throw new Error("No Render owner found");
+      const servicePayload = {
+        type: "web_service",
+        name: config.customConfig?.environmentVariables?.SERVICE_NAME || `moltium-agent-${Date.now()}`,
+        ownerId,
+        repo: config.customConfig?.environmentVariables?.REPO_URL,
+        autoDeploy: "yes",
+        branch: "main",
+        plan: config.instanceType || "starter",
+        region: config.region || "oregon",
+        runtime: "node",
+        buildCommand: config.customConfig?.buildCommand || "npm install && npm run build",
+        startCommand: config.customConfig?.startCommand || "npm start",
+        envVars: Object.entries(config.customConfig?.environmentVariables || {}).map(([key, value]) => ({
+          key,
+          value
+        }))
+      };
+      const createRes = await axios.post(`${RENDER_API}/services`, servicePayload, { headers: this.headers });
+      const service = createRes.data.service;
+      logs.push(`Service created: ${service.id}`);
+      logs.push(`Service URL: https://${service.serviceDetails?.url || service.slug + ".onrender.com"}`);
+      const deployRes = await axios.post(
+        `${RENDER_API}/services/${service.id}/deploys`,
+        {},
+        { headers: this.headers }
+      );
+      logs.push(`Deployment triggered: ${deployRes.data.id}`);
+      const result = {
+        success: true,
+        url: `https://${service.serviceDetails?.url || service.slug + ".onrender.com"}`,
+        deploymentId: service.id,
+        logs
+      };
+      await this.postDeploy(result);
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        logs
+      };
+    }
+  }
+  async postDeploy(result) {
+    if (result.url) {
+      result.logs?.push(`View dashboard: https://dashboard.render.com`);
+    }
+  }
+  async getStatus(deploymentId) {
+    try {
+      const res = await axios.get(`${RENDER_API}/services/${deploymentId}`, { headers: this.headers });
+      const service = res.data;
+      const stateMap = {
+        running: "running",
+        suspended: "stopped",
+        deploying: "deploying"
+      };
+      return {
+        state: stateMap[service.suspended] || "unknown",
+        url: `https://${service.serviceDetails?.url}`
+      };
+    } catch {
+      return { state: "unknown" };
+    }
+  }
+  async rollback(deploymentId) {
+    try {
+      const deploysRes = await axios.get(
+        `${RENDER_API}/services/${deploymentId}/deploys?limit=5`,
+        { headers: this.headers }
+      );
+      const lastSuccess = deploysRes.data.find((d) => d.deploy.status === "live");
+      if (!lastSuccess) throw new Error("No previous successful deployment found");
+      await axios.post(
+        `${RENDER_API}/services/${deploymentId}/deploys`,
+        { commitId: lastSuccess.deploy.commit?.id },
+        { headers: this.headers }
+      );
+    } catch (error) {
+      throw new Error(`Rollback failed: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+};
+
+// src/deployers/aws.ts
+var AWSDeployer = class extends BaseDeployer {
+  name = "aws";
+  description = "Deploy to AWS (ECS/Fargate)";
+  async validate(config) {
+    if (config.platform !== "aws") {
+      throw new Error('Config platform must be "aws"');
+    }
+    return true;
+  }
+  async preCheck() {
+    try {
+      await exec("aws", ["--version"]);
+    } catch {
+      throw new Error(
+        "AWS CLI not found. Install it:\n  https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html"
+      );
+    }
+    try {
+      await exec("aws", ["sts", "get-caller-identity"]);
+    } catch {
+      throw new Error("AWS credentials not configured. Run: aws configure");
+    }
+  }
+  async deploy(config) {
+    await this.validate(config);
+    await this.preCheck();
+    const logs = [];
+    const region = config.region || "us-east-1";
+    const serviceName = config.customConfig?.environmentVariables?.SERVICE_NAME || `moltium-agent`;
+    try {
+      logs.push("Ensuring ECR repository exists...");
+      try {
+        await exec("aws", [
+          "ecr",
+          "describe-repositories",
+          "--repository-names",
+          serviceName,
+          "--region",
+          region
+        ]);
+        logs.push("ECR repository exists.");
+      } catch {
+        await exec("aws", [
+          "ecr",
+          "create-repository",
+          "--repository-name",
+          serviceName,
+          "--region",
+          region
+        ]);
+        logs.push("ECR repository created.");
+      }
+      logs.push("Logging in to ECR...");
+      const ecrPasswordResult = await exec("aws", [
+        "ecr",
+        "get-login-password",
+        "--region",
+        region
+      ]);
+      const accountId = (await exec("aws", ["sts", "get-caller-identity", "--query", "Account", "--output", "text"])).stdout;
+      const ecrUrl = `${accountId}.dkr.ecr.${region}.amazonaws.com`;
+      await exec("docker", ["login", "--username", "AWS", "--password", ecrPasswordResult.stdout, ecrUrl]);
+      logs.push("ECR login successful.");
+      logs.push("Building Docker image...");
+      const imageTag = `${ecrUrl}/${serviceName}:latest`;
+      await exec("docker", ["build", "-t", imageTag, "."]);
+      logs.push("Docker image built.");
+      logs.push("Pushing to ECR...");
+      await exec("docker", ["push", imageTag]);
+      logs.push("Image pushed to ECR.");
+      logs.push("Updating ECS service...");
+      const taskDef = {
+        family: serviceName,
+        networkMode: "awsvpc",
+        requiresCompatibilities: ["FARGATE"],
+        cpu: config.instanceType || "256",
+        memory: "512",
+        containerDefinitions: [{
+          name: serviceName,
+          image: imageTag,
+          essential: true,
+          portMappings: [{
+            containerPort: config.customConfig?.port || 3e3,
+            protocol: "tcp"
+          }],
+          environment: Object.entries(config.customConfig?.environmentVariables || {}).map(([name, value]) => ({
+            name,
+            value
+          })),
+          logConfiguration: {
+            logDriver: "awslogs",
+            options: {
+              "awslogs-group": `/ecs/${serviceName}`,
+              "awslogs-region": region,
+              "awslogs-stream-prefix": "ecs"
+            }
+          }
+        }]
+      };
+      const { writeFileSync, unlinkSync, mkdtempSync } = await import("fs");
+      const { join: join4 } = await import("path");
+      const tmpDir = mkdtempSync(join4((await import("os")).tmpdir(), "molt-"));
+      const taskDefPath = join4(tmpDir, "task-def.json");
+      writeFileSync(taskDefPath, JSON.stringify(taskDef));
+      await exec("aws", [
+        "ecs",
+        "register-task-definition",
+        "--cli-input-json",
+        `file://${taskDefPath}`,
+        "--region",
+        region
+      ]);
+      unlinkSync(taskDefPath);
+      logs.push("Task definition registered.");
+      try {
+        await exec("aws", [
+          "ecs",
+          "update-service",
+          "--cluster",
+          "default",
+          "--service",
+          serviceName,
+          "--task-definition",
+          serviceName,
+          "--force-new-deployment",
+          "--region",
+          region
+        ]);
+        logs.push("ECS service updated.");
+      } catch {
+        logs.push("Service not found, creating new ECS service...");
+        logs.push("Note: ECS service creation requires VPC/subnet configuration.");
+        logs.push('Use "aws ecs create-service" with your VPC settings.');
+      }
+      const result = {
+        success: true,
+        deploymentId: `aws-${serviceName}`,
+        logs
+      };
+      await this.postDeploy(result);
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        logs
+      };
+    }
+  }
+  async postDeploy(result) {
+    result.logs?.push("Check AWS ECS console for deployment status.");
+  }
+  async getStatus(deploymentId) {
+    const serviceName = deploymentId.replace("aws-", "");
+    try {
+      const result = await exec("aws", [
+        "ecs",
+        "describe-services",
+        "--cluster",
+        "default",
+        "--services",
+        serviceName,
+        "--query",
+        "services[0].status",
+        "--output",
+        "text"
+      ]);
+      const status = result.stdout.toLowerCase();
+      if (status === "active") return { state: "running" };
+      if (status === "draining") return { state: "stopping" };
+      return { state: "unknown" };
+    } catch {
+      return { state: "unknown" };
+    }
+  }
+  async rollback(deploymentId) {
+    const serviceName = deploymentId.replace("aws-", "");
+    try {
+      const result = await exec("aws", [
+        "ecs",
+        "list-task-definitions",
+        "--family-prefix",
+        serviceName,
+        "--sort",
+        "DESC",
+        "--max-items",
+        "2",
+        "--query",
+        "taskDefinitionArns[1]",
+        "--output",
+        "text"
+      ]);
+      const previousRevision = result.stdout.trim();
+      if (!previousRevision || previousRevision === "None") {
+        throw new Error("No previous task definition found for rollback");
+      }
+      await exec("aws", [
+        "ecs",
+        "update-service",
+        "--cluster",
+        "default",
+        "--service",
+        serviceName,
+        "--task-definition",
+        previousRevision,
+        "--force-new-deployment"
+      ]);
+    } catch (error) {
+      throw new Error(`Rollback failed: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+};
+
+// src/deployers/digitalocean.ts
+import axios2 from "axios";
+var DO_API = "https://api.digitalocean.com/v2";
+var DigitalOceanDeployer = class extends BaseDeployer {
+  name = "digitalocean";
+  description = "Deploy to DigitalOcean App Platform";
+  get apiToken() {
+    const token = process.env.DO_API_TOKEN;
+    if (!token) throw new Error("DO_API_TOKEN environment variable is required");
+    return token;
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.apiToken}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async validate(config) {
+    if (config.platform !== "digitalocean") {
+      throw new Error('Config platform must be "digitalocean"');
+    }
+    if (!process.env.DO_API_TOKEN) {
+      throw new Error("DO_API_TOKEN environment variable is required");
+    }
+    return true;
+  }
+  async preCheck() {
+    try {
+      await axios2.get(`${DO_API}/account`, { headers: this.headers });
+    } catch {
+      throw new Error("Failed to authenticate with DigitalOcean API. Check your DO_API_TOKEN.");
+    }
+  }
+  async deploy(config) {
+    await this.validate(config);
+    await this.preCheck();
+    const logs = [];
+    const appName = config.customConfig?.environmentVariables?.APP_NAME || `moltium-agent-${Date.now()}`;
+    const region = config.region || "nyc";
+    try {
+      logs.push("Creating DigitalOcean App...");
+      const appSpec = {
+        name: appName,
+        region,
+        services: [{
+          name: appName,
+          source_dir: "/",
+          github: config.customConfig?.environmentVariables?.GITHUB_REPO ? {
+            repo: config.customConfig.environmentVariables.GITHUB_REPO,
+            branch: config.customConfig.environmentVariables.GITHUB_BRANCH || "main",
+            deploy_on_push: true
+          } : void 0,
+          dockerfile_path: config.customConfig?.environmentVariables?.DOCKERFILE_PATH,
+          build_command: config.customConfig?.buildCommand || "npm install && npm run build",
+          run_command: config.customConfig?.startCommand || "npm start",
+          instance_size_slug: config.instanceType || "basic-xxs",
+          instance_count: 1,
+          http_port: config.customConfig?.port || 3e3,
+          envs: Object.entries(config.customConfig?.environmentVariables || {}).filter(([key]) => !["APP_NAME", "GITHUB_REPO", "GITHUB_BRANCH", "DOCKERFILE_PATH"].includes(key)).map(([key, value]) => ({
+            key,
+            value,
+            scope: "RUN_AND_BUILD_TIME"
+          }))
+        }]
+      };
+      const createRes = await axios2.post(`${DO_API}/apps`, { spec: appSpec }, { headers: this.headers });
+      const app = createRes.data.app;
+      logs.push(`App created: ${app.id}`);
+      let url;
+      try {
+        const statusRes = await axios2.get(`${DO_API}/apps/${app.id}`, { headers: this.headers });
+        url = statusRes.data.app.live_url || statusRes.data.app.default_ingress;
+      } catch {
+      }
+      const result = {
+        success: true,
+        url,
+        deploymentId: app.id,
+        logs
+      };
+      await this.postDeploy(result);
+      return result;
+    } catch (error) {
+      const msg = axios2.isAxiosError(error) ? error.response?.data?.message || error.message : error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: msg,
+        logs
+      };
+    }
+  }
+  async postDeploy(result) {
+    result.logs?.push(`View dashboard: https://cloud.digitalocean.com/apps/${result.deploymentId}`);
+  }
+  async getStatus(deploymentId) {
+    try {
+      const res = await axios2.get(`${DO_API}/apps/${deploymentId}`, { headers: this.headers });
+      const app = res.data.app;
+      const phase = app.active_deployment?.phase?.toLowerCase();
+      const stateMap = {
+        active: "running",
+        deploying: "deploying",
+        building: "deploying",
+        error: "failed"
+      };
+      return {
+        state: stateMap[phase] || (app.live_url ? "running" : "unknown"),
+        url: app.live_url || app.default_ingress
+      };
+    } catch {
+      return { state: "unknown" };
+    }
+  }
+  async rollback(deploymentId) {
+    try {
+      const res = await axios2.get(`${DO_API}/apps/${deploymentId}/deployments?per_page=5`, { headers: this.headers });
+      const deployments = res.data.deployments || [];
+      const previousActive = deployments.find((d) => d.phase === "ACTIVE" && d !== deployments[0]);
+      if (!previousActive) {
+        throw new Error("No previous successful deployment found for rollback");
+      }
+      await axios2.post(
+        `${DO_API}/apps/${deploymentId}/rollback`,
+        { deployment_id: previousActive.id },
+        { headers: this.headers }
+      );
+    } catch (error) {
+      if (axios2.isAxiosError(error) && error.response?.status === 404) {
+        throw new Error("Rollback not supported. Manually redeploy from the DigitalOcean dashboard.");
+      }
+      throw new Error(`Rollback failed: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+};
+
+// src/deployers/custom.ts
+import axios3 from "axios";
+var CustomDeploymentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CustomDeploymentError";
+  }
+};
+var CustomDeployer = class extends BaseDeployer {
+  name = "custom";
+  description = "Deploy using custom configuration";
+  async validate(config) {
+    if (!config.customConfig) {
+      throw new CustomDeploymentError("Custom deployment requires customConfig object");
+    }
+    const required = ["deploymentMethod", "buildCommand", "startCommand"];
+    for (const field of required) {
+      if (!config.customConfig[field]) {
+        throw new CustomDeploymentError(`Custom deployment missing required field: ${field}`);
+      }
+    }
+    const validMethods = ["docker", "ssh", "cli", "api"];
+    if (!validMethods.includes(config.customConfig.deploymentMethod)) {
+      throw new CustomDeploymentError(
+        `Invalid deployment method: ${config.customConfig.deploymentMethod}. Must be one of: ${validMethods.join(", ")}`
+      );
+    }
+    return true;
+  }
+  async preCheck() {
+  }
+  async deploy(config) {
+    await this.validate(config);
+    const custom = config.customConfig;
+    switch (custom.deploymentMethod) {
+      case "docker":
+        return this.deployDocker(custom);
+      case "ssh":
+        return this.deploySSH(custom);
+      case "cli":
+        return this.deployCLI(custom);
+      case "api":
+        return this.deployAPI(custom);
+      default:
+        throw new CustomDeploymentError(`Unsupported deployment method: ${custom.deploymentMethod}`);
+    }
+  }
+  async postDeploy(_result) {
+  }
+  async getStatus(deploymentId) {
+    try {
+      const url = deploymentId;
+      if (url.startsWith("http")) {
+        const res = await axios3.get(url, { timeout: 5e3 });
+        if (res.status === 200) return { state: "running", url };
+      }
+    } catch {
+    }
+    return { state: "unknown" };
+  }
+  async rollback(_deploymentId) {
+    throw new CustomDeploymentError("Rollback is deployment-method specific. Implement in your deployment pipeline.");
+  }
+  // ── Docker Method ──
+  async deployDocker(config) {
+    if (!config.docker) {
+      throw new CustomDeploymentError("Docker config required for docker deployment method");
+    }
+    const logs = [];
+    const { docker } = config;
+    try {
+      logs.push("Building Docker image...");
+      const dockerfile = docker.dockerfile || "Dockerfile";
+      const tag = docker.tag || "latest";
+      const imageName = `${docker.registry}/${docker.imageName}:${tag}`;
+      const buildArgs = docker.buildArgs ? Object.entries(docker.buildArgs).flatMap(([k, v]) => ["--build-arg", `${k}=${v}`]) : [];
+      await exec("docker", ["build", "-f", dockerfile, "-t", imageName, ...buildArgs, "."]);
+      logs.push(`Image built: ${imageName}`);
+      if (docker.registryAuth) {
+        logs.push(`Logging in to registry: ${docker.registry}...`);
+        await exec("docker", [
+          "login",
+          docker.registry,
+          "-u",
+          docker.registryAuth.username,
+          "-p",
+          docker.registryAuth.password
+        ]);
+        logs.push("Registry login successful.");
+      }
+      logs.push("Pushing image to registry...");
+      await exec("docker", ["push", imageName]);
+      logs.push("Image pushed.");
+      logs.push(`Deploying to ${docker.hostUrl}...`);
+      if (docker.hostUrl === "localhost" || docker.hostUrl === "127.0.0.1") {
+        try {
+          await exec("docker", ["stop", docker.imageName]);
+          await exec("docker", ["rm", docker.imageName]);
+        } catch {
+        }
+        await exec("docker", ["pull", imageName]);
+        const envArgs = config.environmentVariables ? Object.entries(config.environmentVariables).flatMap(([k, v]) => ["-e", `${k}=${v}`]) : [];
+        await exec("docker", [
+          "run",
+          "-d",
+          "--name",
+          docker.imageName,
+          "-p",
+          `${docker.hostPort}:${docker.containerPort}`,
+          ...envArgs,
+          imageName
+        ]);
+        logs.push(`Container running on port ${docker.hostPort}`);
+      } else {
+        logs.push(`Remote Docker host deployment: Pull ${imageName} on ${docker.hostUrl} and run with port ${docker.hostPort}:${docker.containerPort}`);
+      }
+      const healthUrl = config.healthCheckUrl || `http://localhost:${docker.hostPort}/health`;
+      return {
+        success: true,
+        url: `http://localhost:${docker.hostPort}`,
+        deploymentId: healthUrl,
+        logs
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        logs
+      };
+    }
+  }
+  // ── SSH Method ──
+  async deploySSH(config) {
+    if (!config.ssh) {
+      throw new CustomDeploymentError("SSH config required for ssh deployment method");
+    }
+    const logs = [];
+    const { ssh } = config;
+    try {
+      const sshTarget = `${ssh.username}@${ssh.host}`;
+      const sshPort = ssh.port || 22;
+      const sshBaseArgs = ["-p", String(sshPort), "-o", "StrictHostKeyChecking=no"];
+      if (ssh.authMethod === "privateKey" && ssh.privateKeyPath) {
+        sshBaseArgs.push("-i", ssh.privateKeyPath);
+      }
+      if (ssh.preDeployCommands && ssh.preDeployCommands.length > 0) {
+        logs.push("Running pre-deploy commands...");
+        for (const cmd of ssh.preDeployCommands) {
+          await exec("ssh", [...sshBaseArgs, sshTarget, cmd]);
+          logs.push(`  Pre-deploy: ${cmd}`);
+        }
+      }
+      logs.push(`Building: ${config.buildCommand}`);
+      const [buildCmd, ...buildArgs] = config.buildCommand.split(" ");
+      await exec(buildCmd, buildArgs);
+      logs.push("Build complete.");
+      logs.push(`Deploying to ${sshTarget}:${ssh.deploymentPath}...`);
+      await exec("ssh", [...sshBaseArgs, sshTarget, `mkdir -p ${ssh.deploymentPath}`]);
+      const rsyncArgs = [
+        "-avz",
+        "--delete",
+        "-e",
+        `ssh ${sshBaseArgs.join(" ")}`,
+        "./",
+        `${sshTarget}:${ssh.deploymentPath}/`
+      ];
+      await exec("rsync", rsyncArgs);
+      logs.push("Files synced.");
+      logs.push(`Starting: ${config.startCommand}`);
+      await exec("ssh", [
+        ...sshBaseArgs,
+        sshTarget,
+        `cd ${ssh.deploymentPath} && ${config.startCommand}`
+      ]);
+      logs.push("Service started.");
+      if (ssh.postDeployCommands && ssh.postDeployCommands.length > 0) {
+        logs.push("Running post-deploy commands...");
+        for (const cmd of ssh.postDeployCommands) {
+          await exec("ssh", [...sshBaseArgs, sshTarget, cmd]);
+          logs.push(`  Post-deploy: ${cmd}`);
+        }
+      }
+      const healthUrl = config.healthCheckUrl || `http://${ssh.host}:${config.port || 3e3}/health`;
+      return {
+        success: true,
+        url: `http://${ssh.host}:${config.port || 3e3}`,
+        deploymentId: healthUrl,
+        logs
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        logs
+      };
+    }
+  }
+  // ── CLI Method ──
+  async deployCLI(config) {
+    if (!config.cli) {
+      throw new CustomDeploymentError("CLI config required for cli deployment method");
+    }
+    const logs = [];
+    const { cli } = config;
+    try {
+      if (cli.installCommand) {
+        logs.push(`Installing CLI: ${cli.installCommand}`);
+        const [installCmd, ...installArgs] = cli.installCommand.split(" ");
+        await exec(installCmd, installArgs);
+        logs.push("CLI installed.");
+      }
+      if (cli.loginCommand) {
+        logs.push(`Logging in: ${cli.loginCommand}`);
+        const [loginCmd, ...loginArgs] = cli.loginCommand.split(" ");
+        await exec(loginCmd, loginArgs);
+        logs.push("Login successful.");
+      }
+      logs.push(`Building: ${config.buildCommand}`);
+      const [buildCmd, ...buildArgs] = config.buildCommand.split(" ");
+      await exec(buildCmd, buildArgs);
+      logs.push("Build complete.");
+      logs.push(`Deploying: ${cli.deployCommand}`);
+      const [deployCmd, ...deployArgs] = cli.deployCommand.split(" ");
+      const deployResult = await exec(deployCmd, deployArgs);
+      logs.push(deployResult.stdout);
+      let url;
+      if (cli.statusCommand) {
+        const [statusCmd, ...statusArgs] = cli.statusCommand.split(" ");
+        const statusResult = await exec(statusCmd, statusArgs);
+        logs.push(statusResult.stdout);
+        const urlMatch = statusResult.stdout.match(/https?:\/\/[^\s]+/);
+        if (urlMatch) url = urlMatch[0];
+      }
+      return {
+        success: true,
+        url,
+        deploymentId: `cli-${cli.cliName}-${Date.now()}`,
+        logs
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        logs
+      };
+    }
+  }
+  // ── API Method ──
+  async deployAPI(config) {
+    if (!config.api) {
+      throw new CustomDeploymentError("API config required for api deployment method");
+    }
+    const logs = [];
+    const { api } = config;
+    try {
+      logs.push(`Building: ${config.buildCommand}`);
+      const [buildCmd, ...buildArgs] = config.buildCommand.split(" ");
+      await exec(buildCmd, buildArgs);
+      logs.push("Build complete.");
+      const headers = {
+        "Content-Type": "application/json",
+        ...api.headers || {}
+      };
+      switch (api.authType) {
+        case "bearer":
+          headers["Authorization"] = `Bearer ${api.authToken}`;
+          break;
+        case "apiKey":
+          headers["X-API-Key"] = api.apiKey || "";
+          break;
+        case "basic":
+          headers["Authorization"] = `Basic ${Buffer.from(api.authToken || "").toString("base64")}`;
+          break;
+        case "custom":
+          break;
+      }
+      const deployUrl = `${api.baseUrl}${api.endpoints.deploy}`;
+      const method = api.requestMethod || "POST";
+      const payload = api.payloadTemplate || {
+        name: config.environmentVariables?.SERVICE_NAME || "moltium-agent",
+        buildCommand: config.buildCommand,
+        startCommand: config.startCommand,
+        envVars: config.environmentVariables
+      };
+      logs.push(`Calling deploy API: ${method} ${deployUrl}`);
+      const response = method === "PUT" ? await axios3.put(deployUrl, payload, { headers }) : await axios3.post(deployUrl, payload, { headers });
+      logs.push(`API response: ${response.status}`);
+      const deploymentId = response.data.id || response.data.deploymentId || `api-${Date.now()}`;
+      let url = response.data.url || response.data.deployUrl;
+      if (api.endpoints.status) {
+        const statusUrl = `${api.baseUrl}${api.endpoints.status}`.replace(":id", deploymentId);
+        try {
+          const statusRes = await axios3.get(statusUrl, { headers });
+          url = url || statusRes.data.url;
+          logs.push(`Status: ${statusRes.data.status || statusRes.data.state || "unknown"}`);
+        } catch {
+        }
+      }
+      return {
+        success: true,
+        url,
+        deploymentId,
+        logs
+      };
+    } catch (error) {
+      const msg = axios3.isAxiosError(error) ? `API error ${error.response?.status}: ${error.response?.data?.message || error.message}` : error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: msg,
+        logs
+      };
+    }
+  }
+};
+
+// src/commands/deploy.ts
+var deployers = {
+  railway: new RailwayDeployer(),
+  render: new RenderDeployer(),
+  aws: new AWSDeployer(),
+  digitalocean: new DigitalOceanDeployer(),
+  custom: new CustomDeployer()
+};
+var deployCommand = new Command3("deploy").description("Deploy agent to cloud platform").argument("[platform]", "Deployment platform (railway, render, aws, digitalocean, custom)").option("-c, --config <file>", "Deployment config file", "deployment.config.ts").action(async (platform, options) => {
+  const agentDir = resolve3(process.cwd());
+  loadEnv2({ path: resolve3(agentDir, ".env") });
+  if (!platform) {
+    console.log(chalk3.yellow("Available deployment platforms:"));
+    for (const [name, deployer2] of Object.entries(deployers)) {
+      console.log(`  ${chalk3.cyan(name)} \u2014 ${deployer2.description}`);
+    }
+    console.log(`
+Usage: ${chalk3.cyan("moltium deploy <platform>")}`);
+    return;
+  }
+  const deployer = deployers[platform];
+  if (!deployer) {
+    console.log(chalk3.red(`Unknown platform: ${platform}`));
+    console.log(`Available: ${Object.keys(deployers).join(", ")}`);
+    process.exit(1);
+  }
+  const spinner = ora3(`Deploying to ${platform}...`).start();
+  try {
+    const configLoader = new ConfigLoader2();
+    await configLoader.load(agentDir);
+    let deployConfig = {
+      platform
+    };
+    const deployConfigPath = resolve3(agentDir, options?.config || "deployment.config.ts");
+    try {
+      const { createJiti } = await import("jiti");
+      const jiti = createJiti(pathToFileURL2(deployConfigPath).href, {
+        interopDefault: true,
+        moduleCache: false
+      });
+      const module = await jiti.import(deployConfigPath);
+      deployConfig = { ...deployConfig, ...module.default || module };
+    } catch {
+    }
+    spinner.text = "Validating deployment configuration...";
+    await deployer.validate(deployConfig);
+    spinner.text = "Running pre-deployment checks...";
+    await deployer.preCheck();
+    spinner.text = `Deploying to ${platform}...`;
+    const result = await deployer.deploy(deployConfig);
+    if (result.success) {
+      await deployer.postDeploy(result);
+      spinner.succeed(chalk3.green(`Deployed to ${platform}!`));
+      if (result.url) {
+        console.log(`  URL: ${chalk3.cyan(result.url)}`);
+      }
+      if (result.deploymentId) {
+        console.log(`  Deployment ID: ${chalk3.gray(result.deploymentId)}`);
+      }
+    } else {
+      spinner.fail(chalk3.red(`Deployment failed: ${result.error}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(chalk3.red("Deployment failed"));
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+
+// src/commands/config.ts
+import { Command as Command4 } from "commander";
+import { resolve as resolve4 } from "path";
+import chalk4 from "chalk";
+import { ConfigLoader as ConfigLoader3 } from "@moltium/core";
+var configCommand = new Command4("config").description("Manage agent configuration");
+configCommand.command("show").description("Show current agent configuration").action(async () => {
+  try {
+    const configLoader = new ConfigLoader3();
+    const { config, type } = await configLoader.load(resolve4(process.cwd()));
+    console.log(chalk4.bold(`
+Agent: ${config.name}`));
+    console.log(`Type: ${config.type || "general"}`);
+    console.log(`Config: ${type}`);
+    console.log(`LLM: ${config.llm.provider} / ${config.llm.model}`);
+    console.log(`Behaviors: ${config.behaviors.decisionMaking}, ${config.behaviors.actionsPerHour || 5} actions/hr`);
+    console.log(`Memory: ${config.memory.type}`);
+    console.log(`Actions: ${config.actions.join(", ") || "none"}`);
+    const platforms = Object.keys(config.social).filter(
+      (k) => config.social[k]?.enabled
+    );
+    console.log(`Social: ${platforms.join(", ") || "none"}`);
+  } catch (error) {
+    console.error(chalk4.red(error instanceof Error ? error.message : "Failed to load config"));
+    process.exit(1);
+  }
+});
+configCommand.command("validate").description("Validate agent configuration").action(async () => {
+  try {
+    const configLoader = new ConfigLoader3();
+    const { config, type } = await configLoader.load(resolve4(process.cwd()));
+    console.log(chalk4.green(`
+\u2713 Valid ${type} configuration for "${config.name}"`));
+  } catch (error) {
+    console.error(chalk4.red(`
+\u2717 ${error instanceof Error ? error.message : "Invalid configuration"}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/migrate.ts
+import { Command as Command5 } from "commander";
+import { resolve as resolve5, join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import chalk5 from "chalk";
+import ora4 from "ora";
+import { ConfigLoader as ConfigLoader4 } from "@moltium/core";
+var migrateCommand = new Command5("migrate").description("Migrate between configuration types").requiredOption("--from <type>", "Source config type (code/markdown)").requiredOption("--to <type>", "Target config type (code/markdown)").option("--dir <directory>", "Agent directory", ".").option("--keep", "Keep the original config file after migration").action(async (options) => {
+  const { from, to, keep } = options;
+  const agentDir = resolve5(process.cwd(), options.dir);
+  if (from === to) {
+    console.log(chalk5.yellow("Source and target config types are the same."));
+    return;
+  }
+  if (!["code", "markdown"].includes(from) || !["code", "markdown"].includes(to)) {
+    console.log(chalk5.red('Config types must be "code" or "markdown".'));
+    process.exit(1);
+  }
+  const spinner = ora4(`Migrating from ${from} to ${to}...`).start();
+  try {
+    const configLoader = new ConfigLoader4();
+    if (from === "code" && to === "markdown") {
+      await migrateCodeToMarkdown(configLoader, agentDir, keep, spinner);
+    } else {
+      await migrateMarkdownToCode(configLoader, agentDir, keep, spinner);
+    }
+    spinner.succeed(chalk5.green(`Migration complete: ${from} \u2192 ${to}`));
+  } catch (error) {
+    spinner.fail(chalk5.red("Migration failed"));
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+async function migrateCodeToMarkdown(configLoader, agentDir, keep, spinner) {
+  const configPath = resolve5(agentDir, "agent.config.ts");
+  if (!existsSync3(configPath)) {
+    throw new Error("No agent.config.ts found in the current directory.");
+  }
+  spinner.text = "Loading code config...";
+  const config = await configLoader.loadCode(configPath);
+  spinner.text = "Generating agent.md...";
+  const socialSections = generateSocialMarkdown(config);
+  const skillSections = config.actions.map((a) => {
+    const name = a.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    return `### ${name}
+Execute the ${a} action based on context and current goals.`;
+  }).join("\n\n");
+  const sleepSchedule = config.behaviors.sleepSchedule ? `${config.behaviors.sleepSchedule.start}:00-${config.behaviors.sleepSchedule.end}:00${config.behaviors.sleepSchedule.timezone ? " " + config.behaviors.sleepSchedule.timezone : " UTC"}` : "none";
+  const agentMd = `# Agent Configuration
+
+## Identity
+name: ${config.name}
+type: ${config.type || "assistant"}
+personality: ${config.personality.traits.join(", ")}
+
+## Bio
+${config.personality.bio}
+
+## Social Platforms
+${socialSections}
+
+## Behaviors
+autonomous: ${config.behaviors.autonomous}
+decision_making: ${config.behaviors.decisionMaking}
+actions_per_hour: ${typeof config.behaviors.actionsPerHour === "number" ? config.behaviors.actionsPerHour : 5}
+sleep_schedule: ${sleepSchedule}
+
+## Memory
+type: ${config.memory.type}
+${config.memory.retention ? `retention: ${config.memory.retention}` : ""}
+
+## Skills
+
+${skillSections}
+`;
+  await writeFile2(join3(agentDir, "agent.md"), agentMd);
+  await mkdir2(join3(agentDir, "personality"), { recursive: true });
+  await writeFile2(join3(agentDir, "personality", "bio.md"), `# ${config.name}
+
+${config.personality.bio}
+`);
+  await writeFile2(join3(agentDir, "personality", "traits.md"), `# ${config.name} \u2014 Traits
+
+${config.personality.traits.map((t) => `### ${t.charAt(0).toUpperCase() + t.slice(1)}
+Describe how this trait manifests in behavior.
+`).join("\n")}`);
+  await mkdir2(join3(agentDir, "skills"), { recursive: true });
+  for (const action of config.actions) {
+    const name = action.replace(/_/g, "-");
+    const title = action.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    await writeFile2(join3(agentDir, "skills", `${name}.md`), `# ${title}
+
+Describe the detailed instructions for this skill.
+`);
+  }
+  await mkdir2(join3(agentDir, "prompts"), { recursive: true });
+  await writeFile2(join3(agentDir, "prompts", "system.md"), `# System Prompt for ${config.name}
+
+${config.llm.systemPrompt || "Add your custom system prompt instructions here."}
+`);
+  await mkdir2(join3(agentDir, "memory"), { recursive: true });
+  await writeFile2(join3(agentDir, "memory", "context.md"), `# ${config.name} \u2014 Long-Term Context
+
+## Important Facts
+- Migrated from code-based configuration
+- Type: ${config.type || "assistant"}
+
+## Current Goals
+1. Continue operating as before
+`);
+  if (!keep) {
+    const { rename } = await import("fs/promises");
+    await rename(configPath, configPath + ".bak");
+    spinner.text = "Original agent.config.ts renamed to agent.config.ts.bak";
+  }
+}
+async function migrateMarkdownToCode(configLoader, agentDir, keep, spinner) {
+  const mdPath = resolve5(agentDir, "agent.md");
+  if (!existsSync3(mdPath)) {
+    throw new Error("No agent.md found in the current directory.");
+  }
+  spinner.text = "Loading markdown config...";
+  const config = await configLoader.loadMarkdown(mdPath);
+  spinner.text = "Generating agent.config.ts...";
+  const socialConfigStr = generateSocialCodeConfig(config);
+  const actionsArrayStr = config.actions.map((a) => `'${a}'`).join(", ");
+  const sleepScheduleStr = config.behaviors.sleepSchedule ? `{ start: ${config.behaviors.sleepSchedule.start}, end: ${config.behaviors.sleepSchedule.end}${config.behaviors.sleepSchedule.timezone ? `, timezone: '${config.behaviors.sleepSchedule.timezone}'` : ""} }` : "undefined";
+  const providerEnvKey = config.llm.provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+  const codeConfig = `import type { AgentConfig } from '@moltium/core';
+
+const config: AgentConfig = {
+  name: '${config.name}',
+  type: '${config.type || "assistant"}',
+
+  personality: {
+    traits: [${config.personality.traits.map((t) => `'${t}'`).join(", ")}],
+    bio: ${JSON.stringify(config.personality.bio)},
+  },
+
+  llm: {
+    provider: '${config.llm.provider}',
+    model: '${config.llm.model}',
+    apiKey: process.env.${providerEnvKey} || '',
+    temperature: ${config.llm.temperature ?? 0.7},
+  },
+
+  social: {
+${socialConfigStr}
+  },
+
+  behaviors: {
+    autonomous: ${config.behaviors.autonomous},
+    decisionMaking: '${config.behaviors.decisionMaking}',
+    actionsPerHour: ${typeof config.behaviors.actionsPerHour === "number" ? config.behaviors.actionsPerHour : 5},
+    sleepSchedule: ${sleepScheduleStr},
+  },
+
+  memory: {
+    type: '${config.memory.type}',
+    ${config.memory.retention ? `retention: '${config.memory.retention}',` : ""}
+  },
+
+  actions: [${actionsArrayStr}],
+};
+
+export default config;
+`;
+  await writeFile2(join3(agentDir, "agent.config.ts"), codeConfig);
+  await mkdir2(join3(agentDir, "hooks"), { recursive: true });
+  await mkdir2(join3(agentDir, "actions"), { recursive: true });
+  const systemPromptPath = join3(agentDir, "prompts", "system.md");
+  if (existsSync3(systemPromptPath)) {
+    const systemPrompt = readFileSync2(systemPromptPath, "utf-8");
+    await writeFile2(join3(agentDir, "hooks", "onInit.ts"), `import type { Agent } from '@moltium/core';
+
+export async function onInit(agent: Agent): Promise<void> {
+  // Migrated system prompt content from prompts/system.md
+  agent.appendSystemPrompt(${JSON.stringify(systemPrompt)});
+
+  const memory = agent.getMemory();
+  await memory.remember('session_started', new Date().toISOString());
+}
+`);
+  } else {
+    await writeFile2(join3(agentDir, "hooks", "onInit.ts"), `import type { Agent } from '@moltium/core';
+
+export async function onInit(agent: Agent): Promise<void> {
+  const memory = agent.getMemory();
+  await memory.remember('session_started', new Date().toISOString());
+}
+`);
+  }
+  await writeFile2(join3(agentDir, "hooks", "onTick.ts"), `import type { Agent } from '@moltium/core';
+
+export async function onTick(agent: Agent): Promise<void> {
+  const memory = agent.getMemory();
+  const count = ((await memory.recall('tick_count')) as number) || 0;
+  await memory.remember('tick_count', count + 1);
+}
+`);
+  await writeFile2(join3(agentDir, "hooks", "onShutdown.ts"), `import type { Agent } from '@moltium/core';
+
+export async function onShutdown(agent: Agent): Promise<void> {
+  const memory = agent.getMemory();
+  await memory.remember('last_shutdown', new Date().toISOString());
+}
+`);
+  if (!existsSync3(join3(agentDir, "tsconfig.json"))) {
+    await writeFile2(join3(agentDir, "tsconfig.json"), JSON.stringify({
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        outDir: "./dist",
+        rootDir: "."
+      },
+      include: ["*.ts", "actions/**/*.ts", "hooks/**/*.ts"]
+    }, null, 2));
+  }
+  if (!keep) {
+    const { rename } = await import("fs/promises");
+    await rename(mdPath, mdPath + ".bak");
+    spinner.text = "Original agent.md renamed to agent.md.bak";
+  }
+}
+function generateSocialMarkdown(config) {
+  const sections = [];
+  const social = config.social || {};
+  for (const [platform, platformConfig] of Object.entries(social)) {
+    if (!platformConfig || typeof platformConfig !== "object") continue;
+    const pc = platformConfig;
+    if (!pc.enabled) continue;
+    const lines = [`### ${platform.charAt(0).toUpperCase() + platform.slice(1)}`];
+    lines.push(`enabled: true`);
+    for (const [key, value] of Object.entries(pc)) {
+      if (key === "enabled" || key === "credentials" || key === "apiKey") continue;
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        lines.push(`${key}: ${value}`);
+      }
+    }
+    sections.push(lines.join("\n"));
+  }
+  return sections.length > 0 ? sections.join("\n\n") : "No social platforms configured.";
+}
+function generateSocialCodeConfig(config) {
+  const social = config.social || {};
+  const lines = [];
+  for (const [platform, platformConfig] of Object.entries(social)) {
+    if (!platformConfig || typeof platformConfig !== "object") continue;
+    const pc = platformConfig;
+    if (platform === "moltbook" && pc.enabled) {
+      lines.push(`    moltbook: {
+      enabled: true,
+      apiKey: process.env.MOLTBOOK_API_KEY || '',
+    },`);
+    } else if (platform === "twitter" && pc.enabled) {
+      lines.push(`    twitter: {
+      enabled: true,
+      credentials: {
+        apiKey: process.env.TWITTER_API_KEY || '',
+        apiSecret: process.env.TWITTER_API_SECRET || '',
+        accessToken: process.env.TWITTER_ACCESS_TOKEN || '',
+        accessSecret: process.env.TWITTER_ACCESS_SECRET || '',
+      },
+    },`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/status.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import axios4 from "axios";
+var statusCommand = new Command6("status").description("Check agent status").option("-r, --remote <url>", "Remote agent URL").option("-p, --port <number>", "Local port", "3000").action(async (options) => {
+  const url = options.remote || `http://localhost:${options.port}`;
+  try {
+    const [health, status] = await Promise.all([
+      axios4.get(`${url}/health`, { timeout: 5e3 }),
+      axios4.get(`${url}/status`, { timeout: 5e3 })
+    ]);
+    const data = status.data;
+    console.log(chalk6.bold(`
+Agent: ${data.name}`));
+    console.log(`State: ${chalk6.green(data.state)}`);
+    console.log(`Type: ${data.type}`);
+    console.log(`Uptime: ${Math.floor(data.uptime)}s`);
+    console.log(`Health: ${chalk6.green(health.data.status)}`);
+  } catch (error) {
+    if (axios4.isAxiosError(error) && error.code === "ECONNREFUSED") {
+      console.log(chalk6.yellow(`
+No agent running at ${url}`));
+    } else {
+      console.error(chalk6.red(`
+Failed to reach agent at ${url}`));
+      console.error(error instanceof Error ? error.message : error);
+    }
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command7();
+program.name("moltium").description("Moltium Agent SDK \u2014 create and manage autonomous AI agents").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(startCommand);
+program.addCommand(deployCommand);
+program.addCommand(configCommand);
+program.addCommand(migrateCommand);
+program.addCommand(statusCommand);
+program.parse();
+//# sourceMappingURL=index.js.map