diff --git a/.clauderc b/.clauderc
new file mode 100644
index 0000000000..22e5c7b439
--- /dev/null
+++ b/.clauderc
@@ -0,0 +1 @@
+{"systemPromptFile": "CLAUDE.md"}
diff --git a/.gptrc b/.gptrc
new file mode 100644
index 0000000000..1c5ffcedbd
--- /dev/null
+++ b/.gptrc
@@ -0,0 +1 @@
+{"configFile": "GPT.json"}
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 120000
index 0000000000..f539fe5a97
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+.continuum/claude/config.md
\ No newline at end of file
diff --git a/GPT.json b/GPT.json
new file mode 120000
index 0000000000..3ef8097aff
--- /dev/null
+++ b/GPT.json
@@ -0,0 +1 @@
+.continuum/gpt/config.json
\ No newline at end of file
diff --git a/README.md b/README.md
index 5d278992c3..b523fb8211 100644
--- a/README.md
+++ b/README.md
@@ -9,10 +9,20 @@
 
 ## 🧠 What is Continuum?
 
-**Continuum** is a protocol and CLI tool that configures AI assistants across all your projects, repos, and teams — giving you **persistent, personalized, and policy-aware AI behavior**, no matter where or how you're working.
+**Continuum** is a context-aware protocol and CLI tool that configures AI assistants across all your projects, repos, and teams — giving you **persistent, personalized, and policy-aware AI behavior**, no matter where or how you're working.
 
 It's like `.editorconfig` or `tsconfig.json` — but for **your AI collaborators**.
 
+### 🌟 Context-Aware Intelligence
+
+Continuum's CLI is designed with a "zero-friction cognition" paradigm:
+
+- **Run `continuum` → and the AI figures out what to do** based on your environment
+- **Intelligent context detection** analyzes your repository state, configs, and integrations
+- **Automatic action determination** so you don't need to remember command verbs
+- **Personalized suggestions** based on your project's specific needs
+- **Seamless integration** with Claude, GPT, and other AI assistants
+
 ## 🚀 Quick Start
 
 ### Requirements
@@ -35,26 +45,30 @@ npm link
 ### Usage
 
 ```bash
+# Just run continuum - it will intelligently detect what to do
+continuum
+
 # Initialize a new .continuum configuration
-continuum init
+continuum --template tdd
 
-# Use a specific template
-continuum init --template tdd
+# Generate assistant-specific configurations
+continuum --assistant claude
+continuum --assistant gpt
 
-# Validate an existing .continuum file
-continuum validate
+# Create symlinks for tool integration
+continuum --assistant claude --create-link  # Creates CLAUDE.md symlink
+continuum --assistant gpt --create-link     # Creates GPT.json symlink
 
-# Generate assistant-specific configurations
-continuum adapt --assistant claude
-continuum adapt --assistant gpt
+# Ask your configured AI assistant a question
+continuum --ask "How do I improve error handling in this codebase?"
 
-# Generate configs with symlinks for tool integration
-continuum adapt --assistant claude --create-link  # Creates CLAUDE.md symlink
-continuum adapt --assistant gpt --create-link     # Creates GPT.json symlink
+# Legacy command format (still supported)
+continuum init --template tdd
+continuum adapt --assistant claude
+continuum validate
 ```
 
-
-> Note: The CLI is currently in development mode with placeholder functionality.
+Continuum is context-aware and will automatically detect what to do based on your repository's state. Just run `continuum` and it will figure out the right action!
 
 ## 🚀 How Continuum Helps
 
@@ -72,10 +86,13 @@ continuum adapt --assistant gpt --create-link     # Creates GPT.json symlink
 
 ## ⚙️ What's Automated
 
-- ✅ **CLI wizard** (`continuum init`) generates `.continuum/config.yml` for your repo
+- ✅ **Context detection** analyzes your environment and automatically determines the right action
+- ✅ **CLI wizard** (`continuum` or `continuum init`) generates `.continuum/config.yml` for your repo
 - ✅ **Symlinks** (e.g. `CLAUDE.md`, `GPT.json`) auto-created for integration with AI dev tools
-- ✅ **Validation** (`continuum validate`) checks for config conflicts, missing agents, and more
-- ✅ **Adapters** convert unified config into Claude, GPT, Aria-compatible prompts and JSON
+- ✅ **Validation** automatically checks for config conflicts, missing agents, and suggests fixes
+- ✅ **Adapters** convert unified config into Claude, GPT, and other AI-compatible formats
+- ✅ **Assistant integration** with the `--ask` feature to interact with your configured assistants
+- ✅ **Environment awareness** includes repository, branch, and project-specific context
 - ✅ **Merging logic** (coming soon): blends personal + org + project preferences with conflict resolution
 
 ## 🧩 Templates & Personas
@@ -89,7 +106,7 @@ Continuum ships with pre-configured templates for common development approaches:
 
 ## 📊 Configuration Schema
 
-AI configurations in Continuum follow a standardized schema stored in `.continuum/default/config.md`:
+AI configurations in Continuum follow a standardized schema stored in `.continuum/default/config.md`. The system automatically detects and includes environment information:
 
 ```yaml
 ai_protocol_version: "0.1"
@@ -97,26 +114,44 @@ identity:
   name: "ProjectAssistant"
   role: "Development collaborator"
   purpose: "Help maintain code quality and guide development"
+environment:
+  type: "Node.js/JavaScript"
+  vcs: "git"
+  branch: "main"
 behavior:
   voice: "professional"
   autonomy: "suggest"
   verbosity: "concise"
+  risk_tolerance: "medium"
 capabilities:
-  allowed: ["code_review", "refactoring", "documentation"]
+  allowed: ["code_review", "refactoring", "documentation", "testing"]
   restricted: ["deployment", "database_management"]
 ```
 
-Continuum uses this configuration to generate assistant-specific files in the `.continuum` directory:
+Continuum automatically detects:
+- Your development environment (Node.js, Python, etc.)
+- Version control system and current branch
+- Existing configurations and integrations
+
+Continuum uses this information to generate context-aware assistant-specific files:
 - `.continuum/claude/config.md` for Anthropic's Claude
 - `.continuum/gpt/config.json` for OpenAI's GPT models
+- Additional configurations for other assistants as they're added
 
 ## 🔌 Assistant Adapters
 
 Continuum translates your configuration to various AI assistants:
 
-- **Claude**: Generates config for Claude in `.continuum/claude/config.md` with optional `CLAUDE.md` symlink
-- **ChatGPT**: Creates prompt configurations compatible with OpenAI models in `.continuum/gpt/config.json`
-- *(and more coming soon)*
+### AI Assistant Compatibility
+
+| Assistant | Status | Configuration | Integration | Notes |
+|-----------|--------|---------------|------------|-------|
+| **Claude** | ✅ Available | `.continuum/claude/config.md` | `CLAUDE.md` symlink | Fully supported with Claude Code integration |
+| **GPT** | ✅ Available | `.continuum/gpt/config.json` | `GPT.json` symlink | Full support for ChatGPT and OpenAI models |
+| **Gemini** | 🔜 Planned | `.continuum/gemini/config.json` | `GEMINI.json` symlink | Google Gemini support coming soon |
+| **Llama** | 🔜 Planned | `.continuum/llama/config.md` | `LLAMA.md` symlink | Meta Llama support in development |
+| **Mistral** | 🔜 Planned | `.continuum/mistral/config.json` | `MISTRAL.json` symlink | Mistral AI support planned |
+| **GitHub Copilot** | 🔄 Exploring | TBD | TBD | Investigating integration options |
 
 ### Claude Code Integration
 
@@ -130,6 +165,10 @@ For Claude Code, you can add the following to your `.clauderc`:
 
 When you run `continuum adapt --assistant claude --create-link`, the symlink will ensure Claude Code picks up your configuration.
 
+### GPT Integration
+
+For OpenAI's models, the generated configuration includes appropriate system prompts and parameters that can be used with the OpenAI API or CLI tools.
+
 ## 🛠️ Use Cases
 
 - **Standardize Team Practices**: Ensure all developers get consistent AI help
diff --git a/package.json b/package.json
index 4cb652a7e7..715cb76129 100644
--- a/package.json
+++ b/package.json
@@ -29,9 +29,19 @@
     "assistant",
     "claude",
     "gpt",
+    "gemini",
+    "llama",
+    "mistral",
+    "meta",
+    "anthropic",
+    "openai",
+    "google",
+    "copilot",
     "standardization",
     "cognitive-systems",
-    "devops"
+    "contextual",
+    "devops",
+    "devsecops"
   ],
   "author": "Cambrian Technologies",
   "license": "MIT",
diff --git a/packages/cli/bin/continuum.js b/packages/cli/bin/continuum.js
index 0e6800d769..5a9a3201d2 100755
--- a/packages/cli/bin/continuum.js
+++ b/packages/cli/bin/continuum.js
@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 
-// Simple CLI implementation for Continuum
-// Beta version - full features coming soon
+/**
+ * Continuum - A contextually aware AI configuration protocol
+ * 
+ * This CLI is designed to be simple and automatically do the right thing
+ * based on the context of your project, user profile, and organization.
+ */
 
 import { Command } from 'commander';
 import chalk from 'chalk';
-import fs from 'fs';
-import path from 'path';
-// No need for path and fileURLToPath in this simplified version
+import { analyzeContext, executeAction } from '../src/context.js';
 
 // Check Node.js version
 const currentNodeVersion = process.versions.node;
@@ -25,171 +27,80 @@ if (major < 18) {
   process.exit(1);
 }
 
-// Setup CLI
+// Setup CLI with a simpler interface
 const program = new Command();
 program
   .name('continuum')
   .description('Continuum - Designed by AI and humans for AI and humans')
   .version('0.1.0')
+  .option('-a, --assistant <assistant>', 'Target assistant to configure (claude, gpt)')
+  .option('-t, --template <template>', 'Template to use for initialization')
+  .option('-o, --output <path>', 'Output path for configuration')
+  .option('-c, --config <path>', 'Path to configuration file', '.continuum/default/config.md')
+  .option('-l, --create-link', 'Create a symlink for tool integration')
+  .option('--ask <prompt>', 'Ask AI assistant to perform a task based on your configuration')
   .addHelpText('after', `
 Example usage:
-  ${chalk.cyan('$ continuum init')}               Initialize a new configuration
-  ${chalk.cyan('$ continuum init --template tdd')}  Use the TDD template
-  ${chalk.cyan('$ continuum validate')}           Validate configuration
-  ${chalk.cyan('$ continuum adapt --assistant claude')}  Generate Claude config
-  ${chalk.cyan('$ continuum adapt --assistant claude --create-link')}  Generate config with symlink at CLAUDE.md
+  ${chalk.cyan('$ continuum')}                    Detect context and do the right thing
+  ${chalk.cyan('$ continuum --template tdd')}     Initialize with TDD template
+  ${chalk.cyan('$ continuum --assistant claude')} Generate Claude configuration
+  ${chalk.cyan('$ continuum --create-link')}      Create symlinks for tool integration
+  ${chalk.cyan('$ continuum --ask "Review this PR"')} Send task to configured assistant
   `);
 
-// Helper function to create a basic config
-function createBasicConfig(template = 'standard') {
-  return {
-    ai_protocol_version: "0.1",
-    identity: {
-      name: "ProjectAssistant",
-      role: "Development collaborator",
-      purpose: "Help maintain code quality and guide development"
-    },
-    behavior: {
-      voice: "professional",
-      autonomy: "suggest",
-      verbosity: "concise",
-      risk_tolerance: "medium"
-    },
-    capabilities: {
-      allowed: ["code_review", "refactoring", "documentation", "testing"],
-      restricted: ["deployment", "database_management"]
-    }
-  };
-}
-
-// Generate markdown content
-function generateMarkdown(config) {
-  // Simple YAML stringifier since we can't import yaml in ES modules easily
-  function yamlStringify(obj, indent = 0) {
-    const spaces = ' '.repeat(indent);
-    let result = '';
-    
-    for (const [key, value] of Object.entries(obj)) {
-      if (Array.isArray(value)) {
-        result += `${spaces}${key}:\n`;
-        for (const item of value) {
-          result += `${spaces}  - "${item}"\n`;
-        }
-      } else if (typeof value === 'object' && value !== null) {
-        result += `${spaces}${key}:\n${yamlStringify(value, indent + 2)}`;
-      } else {
-        result += `${spaces}${key}: "${value}"\n`;
-      }
-    }
-    
-    return result;
-  }
-  
-  const yamlStr = yamlStringify(config);
-  
-  return `# Continuum Configuration
-
-\`\`\`yaml
-${yamlStr}
-\`\`\`
-
-## Additional Instructions
-
-This configuration was generated using Continuum - designed by AI and humans for AI and humans.
-
-### Project Context
-
-This defines how AI assistants should interact with this project.
+// Parse arguments
+program.parse(process.argv);
 
-### Workflow Examples
+// Get options
+const options = program.opts();
 
-AI assistants should follow the configuration above when working with this project.
-`;
-}
+// Check for specific commands using positional arguments
+const args = program.args;
+const command = args[0];
 
-// Init command
-program
-  .command('init')
-  .description('Initialize a new AI configuration')
-  .option('-t, --template <template>', 'Use a predefined template')
-  .option('-o, --output <path>', 'Output path for configuration', '.continuum/default/config.md')
-  .action((options) => {
-    console.log(chalk.blue('\nInitializing new AI configuration...'));
-    
-    // Show what we'll do
-    if (options.template) {
-      console.log(`Template: ${chalk.green(options.template)}`);
-    } else {
-      console.log(`Template: ${chalk.green('standard')}`);
-    }
-    console.log(`Output: ${chalk.green(options.output)}`);
-    
-    // Create config
-    const config = createBasicConfig(options.template);
-    const content = generateMarkdown(config);
-    
-    try {
-      // Create directory if it doesn't exist
-      const outputDir = path.dirname(options.output);
-      if (outputDir !== '.') {
-        try {
-          fs.mkdirSync(outputDir, { recursive: true });
-          console.log(`Created directory: ${outputDir}`);
-        } catch (err) {
-          if (err.code !== 'EEXIST') {
-            console.error(chalk.red(`\nError creating directory: ${err.message}`));
-            return;
-          }
+// Special case for legacy command format (continuum init, continuum adapt, etc.)
+if (command) {
+  console.log(chalk.yellow(`Note: The command format 'continuum ${command}' is supported for backward compatibility.`));
+  console.log(chalk.yellow(`In the future, you can simply use 'continuum' with appropriate options.`));
+  console.log('');
+  
+  // Map legacy commands to options
+  switch (command) {
+    case 'init':
+      // Handle init command - options are already parsed correctly
+      break;
+      
+    case 'adapt':
+      // The adapt command usually requires an assistant option
+      if (!options.assistant && args[1]) {
+        if (args[1] === '--assistant' || args[1] === '-a') {
+          options.assistant = args[2];
         }
       }
+      break;
       
-      fs.writeFileSync(options.output, content);
-      console.log(chalk.green(`\nConfiguration written to ${options.output}`));
-    } catch (err) {
-      console.error(chalk.red(`\nError writing configuration: ${err.message}`));
-    }
-  });
-
-// Validate command
-program
-  .command('validate')
-  .description('Validate an existing configuration')
-  .option('-c, --config <path>', 'Path to configuration file', '.continuum/default/config.md')
-  .action((options) => {
-    console.log(chalk.blue('\nValidating configuration...'));
-    
-    try {
-      if (!fs.existsSync(options.config)) {
-        console.error(chalk.red(`\nError: Configuration file not found at ${options.config}`));
-        return;
-      }
+    case 'validate':
+      // Validation will happen by default
+      break;
       
-      console.log(chalk.green(`\nConfiguration file exists at ${options.config}`));
-      console.log(chalk.yellow('Basic validation successful. Schema validation coming soon.'));
-    } catch (err) {
-      console.error(chalk.red(`\nError validating configuration: ${err.message}`));
-    }
-  });
+    default:
+      console.log(chalk.yellow(`Unknown command: ${command}`));
+      // We'll continue with contextual detection
+  }
+}
 
-// Adapt command
-program
-  .command('adapt')
-  .description('Generate assistant-specific configuration')
-  .requiredOption('-a, --assistant <assistant>', 'Target assistant (claude, gpt)')
-  .option('-c, --config <path>', 'Path to configuration file', '.continuum/default/config.md')
-  .option('-o, --output <path>', 'Output path for adapted configuration')
-  .option('-l, --create-link', 'Create a symlink in the root directory (CLAUDE.md or GPT.json)')
-  .action((options) => {
-    // We just delegate to the adapted command implementation
-    import('../src/commands/adapt.js')
-      .then(module => {
-        return module.adaptCommand(options);
-      })
-      .catch(error => {
-        console.error(chalk.red(`\nError: ${error.message}`));
-        process.exit(1);
-      });
-  });
+async function main() {
+  try {
+    // Analyze the current context to determine what to do
+    const contextResult = await analyzeContext(options);
+    
+    // Execute the appropriate action based on the context
+    await executeAction(contextResult, options);
+  } catch (error) {
+    console.error(chalk.red(`\nError: ${error.message}`));
+    process.exit(1);
+  }
+}
 
-// Parse arguments
-program.parse(process.argv);
\ No newline at end of file
+// Run the main function
+main();
\ No newline at end of file
diff --git a/packages/cli/src/ask.js b/packages/cli/src/ask.js
new file mode 100644
index 0000000000..e977f36cbd
--- /dev/null
+++ b/packages/cli/src/ask.js
@@ -0,0 +1,273 @@
+/**
+ * Ask functionality - Send task to configured assistant
+ * Enhanced with context awareness for intelligent assistant interactions
+ */
+
+import fs from 'fs';
+import chalk from 'chalk';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+// Helper for async execution
+const execAsync = promisify(exec);
+
+/**
+ * Send a task to the configured assistant with context awareness
+ */
+export async function askAssistant(prompt, options = {}) {
+  console.log(chalk.blue(`\n🧠 Preparing to ask assistant: "${prompt}"\n`));
+  
+  try {
+    // Gather context information
+    const contextInfo = await gatherContextInfo();
+    
+    // First, determine which assistant to use
+    const assistant = options.assistant || detectDefaultAssistant();
+    
+    if (!assistant) {
+      console.log(chalk.yellow('No assistant specified and could not detect a default.'));
+      console.log(chalk.yellow('Please use --assistant option or configure a default assistant.'));
+      return;
+    }
+    
+    console.log(chalk.dim(`Using ${assistant} assistant...`));
+    
+    // Check if the assistant configuration exists
+    const assistantConfigPath = getAssistantConfigPath(assistant);
+    
+    if (!fs.existsSync(assistantConfigPath)) {
+      console.log(chalk.yellow(`No configuration found for ${assistant} at ${assistantConfigPath}`));
+      console.log(chalk.yellow(`Run 'continuum --assistant ${assistant}' to generate one.`));
+      return;
+    }
+    
+    // Generate the assistant prompt with context awareness
+    const assistantPrompt = generatePromptForAssistant(assistant, prompt, contextInfo);
+    
+    // Display what we would do (actual integration would depend on the assistant)
+    console.log(chalk.green('\nSending to assistant:'));
+    console.log(chalk.dim('-----------------------------------'));
+    console.log(assistantPrompt);
+    console.log(chalk.dim('-----------------------------------'));
+    
+    // Check if we can actually execute a command for this assistant
+    const command = getAssistantCommand(assistant, prompt, contextInfo);
+    
+    if (command) {
+      console.log(chalk.blue('\nExecuting command:'));
+      console.log(chalk.dim(command));
+      console.log('');
+      
+      try {
+        // This is a simulation - in a real implementation, we'd handle this more carefully
+        // This would need proper escaping and security considerations in a real implementation
+        await execAsync(command);
+        console.log(chalk.green('\nCommand executed successfully.'));
+      } catch (error) {
+        console.error(chalk.yellow(`\nCommand execution failed: ${error.message}`));
+        console.log(chalk.yellow('This is just a prototype - full integration coming soon!'));
+      }
+    } else {
+      console.log(chalk.yellow('\nThis is a prototype - full integration coming soon!'));
+      console.log(chalk.yellow('In a complete implementation, this would launch or send the request to the assistant.'));
+    }
+    
+  } catch (error) {
+    console.error(chalk.red(`\nError: ${error.message}`));
+  }
+}
+
+/**
+ * Gather context information about the current environment
+ */
+async function gatherContextInfo() {
+  const contextInfo = {
+    projectInfo: {},
+    repoInfo: {},
+    configInfo: {}
+  };
+  
+  try {
+    // Check for package.json
+    if (fs.existsSync('package.json')) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+        contextInfo.projectInfo = {
+          name: packageJson.name,
+          version: packageJson.version,
+          description: packageJson.description,
+          type: 'Node.js/JavaScript'
+        };
+      } catch (e) {
+        // Ignore parsing errors
+      }
+    }
+    
+    // Check for Git repo
+    if (fs.existsSync('.git')) {
+      try {
+        // Get branch info
+        const headContent = fs.readFileSync('.git/HEAD', 'utf-8');
+        const branchMatch = headContent.match(/ref: refs\/heads\/([^\n]+)/);
+        const branch = branchMatch ? branchMatch[1] : 'unknown';
+        
+        // Get status info (simplified)
+        const { stdout: statusOutput } = await execAsync('git status --porcelain', { timeout: 1000 });
+        const hasChanges = statusOutput.trim().length > 0;
+        
+        contextInfo.repoInfo = {
+          type: 'git',
+          branch,
+          hasChanges
+        };
+      } catch (e) {
+        // Fallback to minimal info
+        contextInfo.repoInfo = { type: 'git' };
+      }
+    }
+    
+    // Check for Continuum configurations
+    contextInfo.configInfo = {
+      hasProjectConfig: fs.existsSync('.continuum/default/config.md'),
+      hasClaudeConfig: fs.existsSync('.continuum/claude/config.md'),
+      hasGptConfig: fs.existsSync('.continuum/gpt/config.json'),
+      hasClaudeSymlink: fs.existsSync('CLAUDE.md'),
+      hasGptSymlink: fs.existsSync('GPT.json'),
+      hasClaudeRC: fs.existsSync('.clauderc')
+    };
+    
+  } catch (error) {
+    // Continue with partial context info
+    console.log(chalk.dim('Note: Could not gather full context information'));
+  }
+  
+  return contextInfo;
+}
+
+/**
+ * Detect the default assistant based on available configurations
+ */
+function detectDefaultAssistant() {
+  // Check if Claude is configured and has symlink
+  if (fs.existsSync('CLAUDE.md') || fs.existsSync('.continuum/claude/config.md')) {
+    return 'claude';
+  }
+  
+  // Check if GPT is configured and has symlink
+  if (fs.existsSync('GPT.json') || fs.existsSync('.continuum/gpt/config.json')) {
+    return 'gpt';
+  }
+  
+  // No assistant configured
+  return null;
+}
+
+/**
+ * Get the path to the assistant configuration
+ */
+function getAssistantConfigPath(assistant) {
+  switch (assistant.toLowerCase()) {
+    case 'claude':
+      // Prefer symlink if it exists
+      return fs.existsSync('CLAUDE.md') 
+        ? 'CLAUDE.md' 
+        : '.continuum/claude/config.md';
+    case 'gpt':
+      // Prefer symlink if it exists
+      return fs.existsSync('GPT.json') 
+        ? 'GPT.json' 
+        : '.continuum/gpt/config.json';
+    default:
+      // Check for specific assistant symlink
+      const customSymlink = `${assistant.toUpperCase()}.md`;
+      if (fs.existsSync(customSymlink)) {
+        return customSymlink;
+      }
+      return `.continuum/${assistant.toLowerCase()}/config.md`;
+  }
+}
+
+/**
+ * Generate a prompt for the specified assistant with context awareness
+ */
+function generatePromptForAssistant(assistant, prompt, contextInfo = {}) {
+  const preamble = `Hello ${assistant}. Load configuration from `;
+  
+  // Common context information for any assistant
+  let contextStr = '';
+  const { projectInfo, repoInfo } = contextInfo;
+  
+  if (projectInfo.name) {
+    contextStr += `\nProject Context: ${projectInfo.name}`;
+    if (projectInfo.description) contextStr += ` - ${projectInfo.description}`;
+    if (projectInfo.type) contextStr += ` (${projectInfo.type})`;
+  }
+  
+  if (repoInfo.type) {
+    contextStr += `\nRepository: ${repoInfo.type}`;
+    if (repoInfo.branch) contextStr += `, branch: ${repoInfo.branch}`;
+    if (repoInfo.hasChanges) contextStr += ` (has uncommitted changes)`;
+  }
+  
+  switch (assistant.toLowerCase()) {
+    case 'claude':
+      const claudeConfig = getAssistantConfigPath('claude');
+      
+      if (!fs.existsSync(claudeConfig)) {
+        return `${preamble}the Continuum configuration.${contextStr}\n\nTask: ${prompt}`;
+      }
+      
+      // Get the first line from the config to extract the role
+      const claudeContent = fs.readFileSync(claudeConfig, 'utf-8');
+      const claudeFirstLine = claudeContent.split('\n')[0] || '';
+      const claudeRole = claudeFirstLine.includes('Configuration for') 
+        ? claudeFirstLine.replace('# Continuum Configuration for ', '') 
+        : 'Claude';
+      
+      return `${preamble}${claudeConfig}. Apply the ${claudeRole} role.${contextStr}\n\nTask: ${prompt}`;
+      
+    case 'gpt':
+      const gptConfig = getAssistantConfigPath('gpt');
+      
+      return `${preamble}${gptConfig}.${contextStr}\n\nTask: ${prompt}`;
+      
+    default:
+      return `${preamble}the Continuum configuration.${contextStr}\n\nTask: ${prompt}`;
+  }
+}
+
+/**
+ * Get a command to execute for the specified assistant (if available)
+ * Enhanced with context awareness
+ */
+function getAssistantCommand(assistant, prompt, contextInfo = {}) {
+  // Escape the prompt for shell
+  const escapedPrompt = prompt.replace(/"/g, '\\"');
+  
+  switch (assistant.toLowerCase()) {
+    case 'claude':
+      // Check for Claude Code CLI 
+      const claudeConfigPath = getAssistantConfigPath('claude');
+      const hasClaudeRC = contextInfo?.configInfo?.hasClaudeRC || fs.existsSync('.clauderc');
+      
+      // Use real Claude command if we know Claude CLI exists
+      // This is a demo command, real implementation would vary
+      if (hasClaudeRC) {
+        return `echo "This would run: claude ask \\"${escapedPrompt}\\""`;
+      } else {
+        return `echo "This would run: claude --system-prompt ${claudeConfigPath} ask \\"${escapedPrompt}\\""`;
+      }
+      
+    case 'gpt':
+      // Check for GPT CLI
+      const gptConfigPath = getAssistantConfigPath('gpt');
+      
+      // Use real GPT command if we know OpenAI CLI exists
+      // This is a demo command, real implementation would vary
+      return `echo "This would run: openai api chat --config ${gptConfigPath} \\"${escapedPrompt}\\""`;
+      
+    default:
+      return `echo "No command configured for assistant: ${assistant}"`;
+  }
+}
\ No newline at end of file
diff --git a/packages/cli/src/context.js b/packages/cli/src/context.js
new file mode 100644
index 0000000000..119938ef04
--- /dev/null
+++ b/packages/cli/src/context.js
@@ -0,0 +1,809 @@
+/**
+ * Context detection for intelligent command execution
+ * This module determines what action to take based on the current environment
+ */
+
+import * as fsPromises from 'fs/promises';
+import fs, { existsSync } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+// We'll import these dynamically to avoid path issues
+// import { adaptCommand } from './commands/adapt.js';
+// import { askAssistant } from './ask.js';
+
+// Default paths
+const USER_CONFIG_PATH = path.resolve(process.env.HOME || process.env.USERPROFILE, '.continuum/profile.yml');
+const PROJECT_CONFIG_PATH = '.continuum/default/config.md';
+const ORG_CONFIG_PATH = '.continuum/org/config.md';
+
+/**
+ * Analyzes the current context to determine what action to take
+ * This is the heart of the context-aware CLI paradigm
+ */
+export async function analyzeContext(options = {}) {
+  console.log(chalk.blue('🧠 Analyzing context...\n'));
+  
+  // Detect repository environment
+  const isGitRepo = await checkIsGitRepo();
+  const gitBranch = isGitRepo ? await getCurrentGitBranch() : null;
+  const hasUncommittedChanges = isGitRepo ? await hasGitChanges() : false;
+  
+  // Check if config files exist
+  const hasProjectConfig = existsSync(PROJECT_CONFIG_PATH);
+  const hasUserConfig = existsSync(USER_CONFIG_PATH);
+  const hasOrgConfig = existsSync(ORG_CONFIG_PATH);
+  
+  // Check if AI assistant integration files exist
+  const hasClaudeConfig = existsSync('.continuum/claude/config.md');
+  const hasGptConfig = existsSync('.continuum/gpt/config.json');
+  const hasClaudeSymlink = existsSync('CLAUDE.md');
+  const hasGptSymlink = existsSync('GPT.json');
+  
+  // Check integration configuration
+  const hasClaudeRC = existsSync('.clauderc');
+  const hasGptRC = existsSync('.gptrc');
+  
+  // Check for specific file types that might indicate project type
+  const hasPackageJson = existsSync('package.json');
+  const hasPythonFiles = await hasPython();
+  const hasDockerfile = existsSync('Dockerfile') || existsSync('docker-compose.yml');
+  
+  // Determine development environment
+  const devEnvironment = detectDevEnvironment(hasPackageJson, hasPythonFiles, hasDockerfile);
+  
+  // Check if specific arguments were passed
+  const hasAssistantArg = options.assistant !== undefined;
+  const hasTemplateArg = options.template !== undefined;
+  const hasAskPrompt = options.ask !== undefined;
+  const hasCreateLink = options.createLink === true;
+  
+  // Log the detected context
+  console.log(chalk.dim('Context detected:'));
+  console.log(chalk.dim(`- Git repository: ${isGitRepo ? '✅' : '❌'}${gitBranch ? ` (${gitBranch})` : ''}`));
+  console.log(chalk.dim(`- Dev environment: ${devEnvironment}`));
+  console.log(chalk.dim(`- Project config: ${hasProjectConfig ? '✅' : '❌'}`));
+  console.log(chalk.dim(`- User config: ${hasUserConfig ? '✅' : '❌'}`));
+  console.log(chalk.dim(`- Organization config: ${hasOrgConfig ? '✅' : '❌'}`));
+  console.log(chalk.dim(`- Claude integration: ${hasClaudeConfig ? '✅' : '❌'}${hasClaudeRC ? ' (with .clauderc)' : ''}`));
+  console.log(chalk.dim(`- GPT integration: ${hasGptConfig ? '✅' : '❌'}${hasGptRC ? ' (with .gptrc)' : ''}`));
+  console.log('');
+  
+  // Build context object for decision making
+  const context = {
+    repo: {
+      isGitRepo,
+      gitBranch,
+      hasUncommittedChanges,
+      devEnvironment
+    },
+    config: {
+      hasProjectConfig,
+      hasUserConfig,
+      hasOrgConfig
+    },
+    integration: {
+      claude: {
+        hasConfig: hasClaudeConfig,
+        hasSymlink: hasClaudeSymlink,
+        hasRC: hasClaudeRC
+      },
+      gpt: {
+        hasConfig: hasGptConfig,
+        hasSymlink: hasGptSymlink,
+        hasRC: hasGptRC
+      }
+    },
+    options
+  };
+  
+  // Determine what to do based on context - prioritize explicit actions
+  if (hasAskPrompt) {
+    // Ask prompt was provided, send to assistant
+    return { 
+      action: 'ask', 
+      message: `Processing request: "${options.ask}"`,
+      context 
+    };
+  }
+  
+  if (hasAssistantArg && hasCreateLink) {
+    // Create symlink for specific assistant
+    return { 
+      action: 'create_symlink', 
+      message: `Creating symlink for ${options.assistant}...`,
+      context 
+    };
+  }
+  
+  if (hasAssistantArg) {
+    // Specific assistant argument was provided, run adapt command
+    return { 
+      action: 'adapt', 
+      message: `Adapting configuration for ${options.assistant}...`,
+      context 
+    };
+  }
+  
+  // Implicit actions based on project state
+  if (!hasProjectConfig) {
+    // No project config found, we should initialize
+    return { 
+      action: 'init', 
+      message: 'No configuration found. Running initialization...',
+      context 
+    };
+  }
+  
+  if (hasProjectConfig && !hasClaudeConfig && !hasGptConfig) {
+    // Project config exists but no assistant configs, suggest adapting
+    return { 
+      action: 'suggest_adapt', 
+      message: 'Configuration exists but no assistant integrations found. Would you like to generate them?',
+      context 
+    };
+  }
+  
+  // Suggest symlink creation if configs exist but no symlinks
+  if ((hasClaudeConfig && !hasClaudeSymlink) || (hasGptConfig && !hasGptSymlink)) {
+    const assistant = hasClaudeConfig && !hasClaudeSymlink ? 'Claude' : 'GPT';
+    return { 
+      action: 'suggest_symlink', 
+      message: `${assistant} configuration found but no symlink. Would you like to create a symlink for tool integration?`,
+      context
+    };
+  }
+  
+  // If we have Claude config and symlink but no .clauderc, suggest creating one
+  if (hasClaudeConfig && hasClaudeSymlink && !hasClaudeRC) {
+    return {
+      action: 'suggest_clauderc',
+      message: 'Claude configuration and symlink found but no .clauderc file to configure Claude Code.',
+      context
+    };
+  }
+  
+  // Default action: validate and report status
+  return { 
+    action: 'validate', 
+    message: 'Validating configuration and checking integrations...',
+    context
+  };
+}
+
+/**
+ * Execute the appropriate action based on context analysis
+ */
+export async function executeAction(contextResult, options = {}) {
+  console.log(chalk.blue(contextResult.message));
+  
+  const context = contextResult.context || {};
+  
+  switch (contextResult.action) {
+    case 'ask':
+      try {
+        const { askAssistant } = await import('./ask.js');
+        await askAssistant(options.ask, options);
+      } catch (error) {
+        console.error(chalk.red(`\nError processing request: ${error.message}`));
+      }
+      break;
+      
+    case 'init':
+      try {
+        // Initialize configuration with enhanced context awareness
+        await initializeConfig(options, context);
+      } catch (error) {
+        console.error(chalk.red(`\nError initializing: ${error.message}`));
+      }
+      break;
+      
+    case 'adapt':
+      try {
+        // Adapt configuration for specific assistant
+        await adaptConfig(options, context);
+      } catch (error) {
+        console.error(chalk.red(`\nError adapting configuration: ${error.message}`));
+      }
+      break;
+      
+    case 'create_symlink':
+      try {
+        // Create symlink only
+        await createSymlink(options.assistant, context);
+      } catch (error) {
+        console.error(chalk.red(`\nError creating symlink: ${error.message}`));
+      }
+      break;
+      
+    case 'suggest_adapt':
+      console.log(chalk.yellow('\nConfiguration exists but no assistant integrations found.'));
+      console.log(chalk.yellow('Would you like to generate configurations for:'));
+      console.log('1. Claude');
+      console.log('2. GPT');
+      console.log('3. Both');
+      console.log('4. Skip');
+      
+      console.log(chalk.green('\nRun one of the following commands:'));
+      console.log(chalk.cyan('continuum --assistant claude'));
+      console.log(chalk.cyan('continuum --assistant gpt'));
+      console.log(chalk.cyan('continuum --assistant claude --assistant gpt'));
+      break;
+      
+    case 'suggest_symlink':
+      // Determine which assistant we're suggesting symlinks for
+      const assistantName = context?.integration?.claude?.hasConfig && !context?.integration?.claude?.hasSymlink
+        ? 'Claude'
+        : 'GPT';
+        
+      console.log(chalk.yellow(`\n${assistantName} configuration found but no symlink for integration.`));
+      console.log(chalk.green('\nRun the following command to create a symlink:'));
+      console.log(chalk.cyan(`continuum --assistant ${assistantName.toLowerCase()} --create-link`));
+      
+      // For Claude, also suggest creating .clauderc if needed
+      if (assistantName === 'Claude' && !context?.integration?.claude?.hasRC) {
+        console.log(chalk.yellow('\nTip: Create a .clauderc file with:'));
+        console.log(`{
+  "systemPromptFile": "CLAUDE.md"
+}`);
+      }
+      break;
+      
+    case 'suggest_clauderc':
+      console.log(chalk.yellow('\nClaude configuration and symlink found, but no .clauderc file.'));
+      console.log(chalk.yellow('To complete Claude Code integration, create a .clauderc file with:'));
+      console.log(`{
+  "systemPromptFile": "CLAUDE.md"
+}`);
+      break;
+      
+    case 'validate':
+      try {
+        // Enhanced validation with context awareness
+        await validateConfig(options, context);
+        
+        // Show detailed integration status
+        showIntegrationStatus(context);
+        
+        // Suggest next steps based on context
+        suggestNextSteps(context);
+      } catch (error) {
+        console.error(chalk.red(`\nError validating: ${error.message}`));
+      }
+      break;
+      
+    default:
+      console.log(chalk.yellow('\nNo specific action needed based on current context.'));
+      console.log(chalk.green('Your configuration is ready for use.'));
+  }
+}
+
+/**
+ * Show integration status with detailed information
+ */
+function showIntegrationStatus(context) {
+  const claudeIntegration = context?.integration?.claude;
+  const gptIntegration = context?.integration?.gpt;
+  
+  console.log(chalk.blue('\n🧩 Integration Status:'));
+  
+  // Claude integration status
+  if (claudeIntegration?.hasConfig) {
+    console.log(`Claude: ${chalk.green('✅ Configured')} ${claudeIntegration.hasSymlink ? chalk.green('✅ Symlinked') : chalk.yellow('⚠️ No symlink')}`);
+    if (claudeIntegration.hasRC) {
+      console.log(`Claude Code: ${chalk.green('✅ .clauderc found')}`);
+    } else if (claudeIntegration.hasSymlink) {
+      console.log(`Claude Code: ${chalk.yellow('⚠️ No .clauderc found')}`);
+    }
+  } else {
+    console.log(`Claude: ${chalk.yellow('⚠️ Not configured')}`);
+  }
+  
+  // GPT integration status
+  if (gptIntegration?.hasConfig) {
+    console.log(`GPT: ${chalk.green('✅ Configured')} ${gptIntegration.hasSymlink ? chalk.green('✅ Symlinked') : chalk.yellow('⚠️ No symlink')}`);
+    if (gptIntegration.hasRC) {
+      console.log(`GPT: ${chalk.green('✅ .gptrc found')}`);
+    } else if (gptIntegration.hasSymlink) {
+      console.log(`GPT: ${chalk.yellow('⚠️ No .gptrc found')}`);
+    }
+  } else {
+    console.log(`GPT: ${chalk.yellow('⚠️ Not configured')}`);
+  }
+  
+  // Show repo context if available
+  if (context?.repo?.isGitRepo) {
+    console.log(chalk.blue('\n📂 Repository Context:'));
+    console.log(`Git branch: ${context.repo.gitBranch || 'unknown'}`);
+    console.log(`Environment: ${context.repo.devEnvironment || 'unknown'}`);
+    console.log(`Changes: ${context.repo.hasUncommittedChanges ? chalk.yellow('⚠️ Uncommitted changes') : chalk.green('✅ Clean working tree')}`);
+  }
+}
+
+/**
+ * Suggest next steps based on context
+ */
+function suggestNextSteps(context) {
+  const suggestions = [];
+  const claudeIntegration = context?.integration?.claude;
+  const gptIntegration = context?.integration?.gpt;
+  
+  if (!context?.config?.hasProjectConfig) {
+    suggestions.push('Initialize project configuration: continuum');
+    // Early return since we need this first
+    if (suggestions.length > 0) {
+      console.log(chalk.blue('\n📋 Suggested actions:'));
+      suggestions.forEach((suggestion, index) => {
+        console.log(`${index + 1}. ${suggestion}`);
+      });
+      return;
+    }
+  }
+  
+  // Claude suggestions
+  if (!claudeIntegration?.hasConfig) {
+    suggestions.push('Generate Claude configuration: continuum --assistant claude');
+  } else if (!claudeIntegration?.hasSymlink) {
+    suggestions.push('Create Claude symlink: continuum --assistant claude --create-link');
+  } else if (!claudeIntegration?.hasRC) {
+    suggestions.push('Create .clauderc file for Claude Code integration');
+  }
+  
+  // GPT suggestions
+  if (!gptIntegration?.hasConfig) {
+    suggestions.push('Generate GPT configuration: continuum --assistant gpt');
+  } else if (!gptIntegration?.hasSymlink) {
+    suggestions.push('Create GPT symlink: continuum --assistant gpt --create-link');
+  } else if (!gptIntegration?.hasRC) {
+    suggestions.push('Create .gptrc file for GPT integration');
+  }
+  
+  // Show suggestions if any
+  if (suggestions.length > 0) {
+    console.log(chalk.blue('\n📋 Suggested actions:'));
+    suggestions.forEach((suggestion, index) => {
+      console.log(`${index + 1}. ${suggestion}`);
+    });
+  } else {
+    console.log(chalk.green('\n🎉 All integrations are set up! Your AI assistants are ready to collaborate.'));
+    console.log(chalk.green('Try using: continuum --ask "Help me with this codebase"'));
+  }
+}
+
+/**
+ * Check if we're in a git repository
+ */
+async function checkIsGitRepo() {
+  try {
+    // Check if .git directory exists
+    return existsSync('.git');
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get current git branch
+ */
+async function getCurrentGitBranch() {
+  try {
+    // Use fsPromises to read the git HEAD file
+    const headContent = await fsPromises.readFile('.git/HEAD', 'utf-8');
+    const match = headContent.match(/ref: refs\/heads\/([^\n]+)/);
+    return match ? match[1] : null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if there are uncommitted changes
+ */
+async function hasGitChanges() {
+  try {
+    // Simple check for uncommitted changes - more complex checking could be done
+    // but this is sufficient for our context detection
+    const gitStatus = await fsPromises.readdir('.git/index');
+    return gitStatus.length > 0;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check for Python files in the project
+ */
+async function hasPython() {
+  try {
+    // Look for .py files in the current directory
+    const files = await fsPromises.readdir('.');
+    return files.some(file => file.endsWith('.py'));
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Detect development environment based on files
+ */
+function detectDevEnvironment(hasPackageJson, hasPythonFiles, hasDockerfile) {
+  if (hasPackageJson) {
+    return 'Node.js/JavaScript';
+  } else if (hasPythonFiles) {
+    return 'Python';
+  } else if (hasDockerfile) {
+    return 'Containerized';
+  } else {
+    return 'Unknown';
+  }
+}
+
+/**
+ * Adapt configuration for specific assistant with context awareness
+ */
+async function adaptConfig(options, context = {}) {
+  const assistant = options.assistant;
+  if (!assistant) {
+    throw new Error('Assistant name is required');
+  }
+  
+  // Get input and output paths
+  const configPath = options.config || PROJECT_CONFIG_PATH;
+  const outputDir = `.continuum/${assistant.toLowerCase()}`;
+  const outputExt = assistant.toLowerCase() === 'gpt' ? 'json' : 'md';
+  const outputPath = options.output || `${outputDir}/config.${outputExt}`;
+  
+  console.log(chalk.yellow(`\nAdapting configuration for ${assistant}...`));
+  console.log(`Input: ${chalk.green(configPath)}`);
+  console.log(`Output: ${chalk.green(outputPath)}`);
+  
+  // Check if input file exists
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  
+  try {
+    // Read configuration file
+    const content = await fsPromises.readFile(configPath, 'utf-8');
+    
+    // Generate assistant-specific configuration
+    let adaptedContent;
+    
+    if (assistant.toLowerCase() === 'claude') {
+      // Use dev environment information if available
+      const devEnv = context?.repo?.devEnvironment || 'Unknown';
+      const isGitRepo = context?.repo?.isGitRepo || false;
+      const gitBranch = context?.repo?.gitBranch || null;
+      
+      // Enhance Claude configuration with context information
+      adaptedContent = `# Continuum Configuration for Claude
+
+## Role and Goal
+You are a development collaborator for a ${devEnv} project${isGitRepo ? ` using Git${gitBranch ? ` (currently on branch: ${gitBranch})` : ''}` : ''}. Your purpose is to help maintain code quality and guide development.
+
+## Constraints
+- Follow the project's best practices
+- Must not introduce security vulnerabilities 
+- Maintain a professional tone
+- Exercise moderate risk tolerance
+
+## Guidelines
+- Suggest improvements but allow the developer to make final decisions
+- Provide concise explanations when suggesting changes
+- Review code thoroughly before suggesting changes
+${isGitRepo ? `- Be aware of the current branch context (${gitBranch || 'unknown'})` : ''}
+
+## Allowed Capabilities
+- Code review
+- Refactoring
+- Documentation
+- Testing
+
+## Restricted Capabilities
+- Deployment
+- Database management
+
+## Additional Instructions
+This configuration was generated using Continuum - designed by AI and humans for AI and humans.`;
+    } else if (assistant.toLowerCase() === 'gpt') {
+      // Use dev environment information if available
+      const devEnv = context?.repo?.devEnvironment || 'Unknown';
+      const isGitRepo = context?.repo?.isGitRepo || false;
+      const gitBranch = context?.repo?.gitBranch || null;
+      
+      adaptedContent = JSON.stringify({
+        model: "gpt-4o",
+        messages: [
+          {
+            role: "system",
+            content: `You are a development collaborator for a ${devEnv} project${isGitRepo ? ` using Git${gitBranch ? ` (currently on branch: ${gitBranch})` : ''}` : ''}. Your purpose is to help maintain code quality and guide development.
+
+# Configuration Parameters
+- Voice: professional
+- Autonomy: suggest (not dictate)
+- Verbosity: concise
+- Risk Tolerance: medium
+
+# Allowed Capabilities
+- Code review
+- Refactoring  
+- Documentation
+- Testing
+
+# Restricted Capabilities
+- Deployment
+- Database management
+
+${isGitRepo ? `# Repository Context\n- Current branch: ${gitBranch || 'unknown'}` : ''}`
+          }
+        ],
+        temperature: 0.7
+      }, null, 2);
+    } else {
+      adaptedContent = `# Continuum Configuration for ${assistant}
+
+Adapted from project configuration.`;
+    }
+    
+    // Create directory if it doesn't exist
+    const outputDirPath = path.dirname(outputPath);
+    if (outputDirPath !== '.') {
+      await fsPromises.mkdir(outputDirPath, { recursive: true });
+      console.log(`Created directory: ${outputDirPath}`);
+    }
+    
+    // Write adapted content
+    await fsPromises.writeFile(outputPath, adaptedContent);
+    console.log(chalk.green(`\nAdapted configuration written to ${outputPath}`));
+    
+    // Create symlink if requested
+    if (options.createLink) {
+      await createSymlink(assistant, context);
+    }
+    
+    // Suggest next steps
+    if (assistant.toLowerCase() === 'claude' && !existsSync('.clauderc')) {
+      console.log(chalk.yellow('\nTip: Create a .clauderc file with:'));
+      console.log(`{
+  "systemPromptFile": "CLAUDE.md"
+}`);
+    }
+  } catch (err) {
+    throw new Error(`Error adapting configuration: ${err.message}`);
+  }
+}
+
+/**
+ * Create symlink for assistant configuration
+ */
+async function createSymlink(assistant, context = {}) {
+  if (!assistant) {
+    throw new Error('Assistant name is required');
+  }
+  
+  const linkName = assistant.toLowerCase() === 'claude' ? 'CLAUDE.md' : 
+                  (assistant.toLowerCase() === 'gpt' ? 'GPT.json' : 
+                  `${assistant.toUpperCase()}.txt`);
+  
+  const configDir = `.continuum/${assistant.toLowerCase()}`;
+  const configExt = assistant.toLowerCase() === 'gpt' ? 'json' : 'md';
+  const configPath = `${configDir}/config.${configExt}`;
+  
+  const linkPath = path.resolve(process.cwd(), linkName);
+  
+  // Check if source file exists
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}. Run 'continuum --assistant ${assistant}' first.`);
+  }
+  
+  // Remove existing symlink if it exists
+  try {
+    if (existsSync(linkPath)) {
+      await fsPromises.unlink(linkPath);
+      console.log(`Removed existing symlink: ${linkPath}`);
+    }
+  } catch (e) {
+    console.error(chalk.yellow(`\nCould not remove existing file: ${e.message}`));
+    console.error(chalk.yellow('You may need administrative privileges to modify files.'));
+    throw new Error(`Failed to remove existing file: ${e.message}`);
+  }
+  
+  try {
+    // Create relative path for symlink
+    const relativePath = path.relative(process.cwd(), configPath);
+    
+    // Create symlink
+    await fsPromises.symlink(relativePath, linkPath);
+    console.log(chalk.green(`\nSymlink created at: ${linkPath}`));
+    
+    // Suggest creating config file if needed
+    if (assistant.toLowerCase() === 'claude' && !existsSync('.clauderc')) {
+      console.log(chalk.yellow('\nTip: Create a .clauderc file with:'));
+      console.log(`{
+  "systemPromptFile": "CLAUDE.md"
+}`);
+    } else if (assistant.toLowerCase() === 'gpt' && !existsSync('.gptrc')) {
+      console.log(chalk.yellow('\nTip: Create a .gptrc file to configure GPT.'));
+    }
+    
+  } catch (e) {
+    console.error(chalk.yellow(`\nCould not create symlink: ${e.message}`));
+    console.error(chalk.yellow('You may need administrative privileges to create symlinks.'));
+    throw new Error(`Failed to create symlink: ${e.message}`);
+  }
+}
+
+/**
+ * Validate configuration with enhanced context awareness
+ */
+async function validateConfig(options, context = {}) {
+  const configPath = options.config || PROJECT_CONFIG_PATH;
+  
+  console.log(chalk.yellow(`\nValidating configuration: ${configPath}`));
+  
+  // Check if config file exists
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  
+  // Read the configuration file
+  const content = await fsPromises.readFile(configPath, 'utf-8');
+  
+  // Check for YAML syntax in markdown files
+  if (configPath.endsWith('.md')) {
+    // Look for yaml blocks
+    const yamlBlockRegex = /```yaml\s+([\s\S]+?)```/;
+    const yamlMatch = content.match(yamlBlockRegex);
+    
+    if (yamlMatch && yamlMatch[1]) {
+      try {
+        // Try to parse YAML
+        // In a real implementation, we would import and use a YAML library here
+        console.log(chalk.dim('Validated YAML syntax in markdown file'));
+      } catch (err) {
+        console.warn(chalk.yellow(`\nWarning: YAML syntax in markdown file may be invalid: ${err.message}`));
+      }
+    }
+  }
+  
+  // Enhanced validation based on context
+  if (context?.repo?.isGitRepo) {
+    console.log(chalk.dim(`Validating in Git repository context (branch: ${context.repo.gitBranch || 'unknown'})`));
+    // In a real implementation, we could do Git-specific validation here
+  }
+  
+  if (context?.repo?.devEnvironment) {
+    console.log(chalk.dim(`Validating for ${context.repo.devEnvironment} development environment`));
+    // In a real implementation, we could do environment-specific validation here
+  }
+  
+  console.log(chalk.green(`\nConfiguration file exists at ${configPath}`));
+  console.log(chalk.green('Basic validation successful.'));
+  
+  return true;
+}
+
+/**
+ * Initialize configuration with context awareness
+ */
+async function initializeConfig(options, context = {}) {
+  console.log(chalk.yellow('\nInitializing configuration...'));
+  
+  const template = options.template || 'standard';
+  const outputPath = options.output || PROJECT_CONFIG_PATH;
+  
+  // Show what we'll do
+  console.log(`Template: ${chalk.green(template)}`);
+  console.log(`Output: ${chalk.green(outputPath)}`);
+  
+  // Enhance configuration with context information
+  const devEnv = context?.repo?.devEnvironment || 'Unknown';
+  const isGitRepo = context?.repo?.isGitRepo || false;
+  const gitBranch = context?.repo?.gitBranch || null;
+  
+  // Create config with context awareness
+  const config = {
+    ai_protocol_version: "0.1",
+    identity: {
+      name: "ProjectAssistant",
+      role: "Development collaborator",
+      purpose: "Help maintain code quality and guide development"
+    },
+    environment: {
+      type: devEnv,
+      vcs: isGitRepo ? "git" : "none",
+      branch: gitBranch || "none"
+    },
+    behavior: {
+      voice: "professional",
+      autonomy: "suggest",
+      verbosity: "concise",
+      risk_tolerance: "medium"
+    },
+    capabilities: {
+      allowed: ["code_review", "refactoring", "documentation", "testing"],
+      restricted: ["deployment", "database_management"]
+    }
+  };
+  
+  // Generate markdown - using a simple YAML stringifier
+  function yamlStringify(obj, indent = 0) {
+    const spaces = ' '.repeat(indent);
+    let result = '';
+    
+    for (const [key, value] of Object.entries(obj)) {
+      if (Array.isArray(value)) {
+        result += `${spaces}${key}:\n`;
+        for (const item of value) {
+          result += `${spaces}  - "${item}"\n`;
+        }
+      } else if (typeof value === 'object' && value !== null) {
+        result += `${spaces}${key}:\n${yamlStringify(value, indent + 2)}`;
+      } else {
+        result += `${spaces}${key}: "${value}"\n`;
+      }
+    }
+    
+    return result;
+  }
+  
+  const yamlStr = yamlStringify(config);
+  const content = `# Continuum Configuration
+
+\`\`\`yaml
+${yamlStr}
+\`\`\`
+
+## Additional Instructions
+
+This configuration was generated using Continuum - designed by AI and humans for AI and humans.
+
+### Project Context
+
+This defines how AI assistants should interact with this project.
+${isGitRepo ? `\nThe project uses Git${gitBranch ? ` and is currently on the ${gitBranch} branch` : ''}.` : ''}
+${devEnv !== 'Unknown' ? `\nThis appears to be a ${devEnv} project.` : ''}
+
+### Workflow Examples
+
+AI assistants should follow the configuration above when working with this project.
+
+Example tasks:
+- Code reviews and suggestions
+- Documentation assistance
+- Refactoring guidance
+- Testing strategy
+`;
+  
+  // Create directory if it doesn't exist
+  const outputDir = path.dirname(outputPath);
+  if (outputDir !== '.') {
+    try {
+      await fsPromises.mkdir(outputDir, { recursive: true });
+      console.log(`Created directory: ${outputDir}`);
+    } catch (err) {
+      if (err.code !== 'EEXIST') {
+        console.error(chalk.red(`\nError creating directory: ${err.message}`));
+        return;
+      }
+    }
+  }
+  
+  await fsPromises.writeFile(outputPath, content);
+  console.log(chalk.green(`\nConfiguration written to ${outputPath}`));
+  
+  // Suggest next steps with context awareness
+  console.log(chalk.blue('\n📋 Suggested next steps:'));
+  console.log('1. Generate Claude configuration: continuum --assistant claude');
+  console.log('2. Generate GPT configuration: continuum --assistant gpt');
+  console.log('3. Create symlinks for tool integration: continuum --create-link');
+  
+  // Special suggestion based on detected environment
+  if (devEnv === 'Node.js/JavaScript') {
+    console.log('\nTip: For JavaScript projects, you might want to add a script to package.json:');
+    console.log(`  "scripts": {
+    "continuum": "continuum"
+  }`);
+  } else if (devEnv === 'Python') {
+    console.log('\nTip: For Python projects, consider integrating with your development workflow.');
+  }
+}
\ No newline at end of file