fraim-framework 2.0.48 → 2.0.49

package/dist/registry/ai-manager-rules/implement-phases/implement-code.md

@@ -177,19 +177,16 @@ Tag tests appropriately to ensure proper test suite execution:
 - **`unit`**: Tests that verify individual functions or classes in isolation
 - **`e2e`**: End-to-end tests that verify complete user workflows
 
-**Smoke Test Execution Rules:**
-If ANY tests are tagged "smoke" or you're modifying core functionality:
-1. **MANDATORY**: Run full smoke test suite: `npm run test-smoke-ci`
-2. **MANDATORY**: Include smoke test output in evidence
-3. **MANDATORY**: All smoke tests must pass before proceeding
-4. **BLOCKING**: Smoke test failures block phase completion
-
 ### Step 7: Basic Compilation Check
 
 **Verify code compiles:**
-```bash
-npx tsc --noEmit --skipLibCheck
-```
+
+**Build Commands**: Always check `.fraim/config.json` first for `customizations.validation.buildCommand`, use that if available, otherwise default to `npm run build`.
+
+**What to Look For**:
+- Exit code 0 (success)
+- No TypeScript compilation errors
+- Clean build output
 
 **Must exit with code 0** (no errors)
 

package/dist/registry/ai-manager-rules/implement-phases/implement-smoke.md

@@ -23,16 +23,17 @@ All technical checks pass, confirming:
 
 ### Step 0: Read Project Validation Commands 📖
 
-**FIRST**: Read your project's validation commands from `.fraim/config.json`:
+**FIRST**: Check your project's custom commands:
 
 ```bash
-# Read the config to get project-specific validation commands
-cat .fraim/config.json
-```
+# Check for custom build command
+cat .fraim/config.json | grep -A 3 "buildCommand"
 
-Look for `customizations.validation.buildCommand` and `customizations.validation.smokeTestCommand`.
+# Check for custom smoke test command  
+cat .fraim/config.json | grep -A 3 "smokeTestCommand"
+```
 
-**Use these commands instead of the generic ones below if they exist.**
+**Use the configured commands if they exist, otherwise use the defaults shown below.**
 
 ### Step 1: Build Compilation Check ✅
 
@@ -43,7 +44,9 @@ Look for `customizations.validation.buildCommand` and `customizations.validation
 
 **Commands to Run** (use customizations.validation.buildCommand from config if available):
 ```bash
-# Run build (use customizations.validation.buildCommand if available, otherwise default)
+# Use project-specific build command from .fraim/config.json if available:
+# - Look for customizations.validation.buildCommand
+# - Use that command if available, otherwise default to:
 npm run build
 ```
 
@@ -164,6 +167,7 @@ npm run build && npm test && git status
 
 ### Technical Standards
 - Read `.fraim/config.json` for the architecture document path (`customizations.architectureDoc`), then read the local architecture document to understand the full technical standards
+- **Config Commands**: Always check `.fraim/config.json` first for `customizations.validation.buildCommand` and `customizations.validation.smokeTestCommand`, use those if available, otherwise use defaults
 - Use Successful Debugging Patterns from `rules/successful-debugging-patterns.md` via `get_fraim_file`
 - When using git commands directly (if MCP tools unavailable), read `rules/git-safe-commands.md` via `get_fraim_file`
 
@@ -181,6 +185,9 @@ npm run build && npm test && git status
 
 **Run smoke tests specifically:**
 ```bash
+# Use project-specific command from .fraim/config.json if available
+# Check: cat .fraim/config.json | grep "smokeTestCommand"
+# Use configured command or default to:
 npm run test-smoke-ci
 ```
 

package/dist/registry/ai-manager-rules/implement-phases/implement-validate.md

@@ -18,6 +18,10 @@ This is THE critical phase where you prove your implementation actually works. N
 
 ## RULES FOR THIS PHASE
 
+### Config-Aware Testing
+**CRITICAL**: Always check `.fraim/config.json` first for project-specific test commands:
+- `customizations.validation.testSuiteCommand` - Use this for comprehensive testing (default: `npm test`)
+
 ### Success Criteria
 Read `registry/rules/agent-success-criteria.md` via `get_fraim_file` for the complete framework. Focus on:
 - **Integrity** (honest reporting of validation results - never claim something works if you didn't test it)
@@ -86,17 +90,17 @@ grep -r "as any" src/ || echo "✅ No type bypassing found"
 
 **Commands to Run** (check .fraim/config.json for project-specific commands first):
 ```bash
-# 1. FIRST: Read your project's validation commands from .fraim/config.json
-cat .fraim/config.json | grep -A 10 "validation"
+# 1. FIRST: Check for custom test commands
+cat .fraim/config.json | grep -A 5 "validation"
 
-# 2. Run the comprehensive test suite (this runs ALL tests)
+# 2. Run comprehensive test suite for current work
+# Use customizations.validation.testSuiteCommand if available, otherwise:
 npm test
 
-# 3. Also run smoke tests specifically to verify core functionality
-npm run test-smoke-ci
-
-# 4. Run all tests in CI mode for complete coverage
-npm run test-all-ci
+# 3. Run targeted tests for your specific changes (if applicable)
+# Example: If you modified user authentication, run auth-related tests
+# npm run test -- --grep "auth"
+# OR: npm run test test-{issue-number}-*.ts
 ```
 
 **What to Look For**:

package/dist/registry/ai-manager-rules/shared-phases/address-pr-feedback.md

@@ -0,0 +1,188 @@
+# Phase: address-pr-feedback
+
+## INTENT
+To systematically address all PR feedback items by making targeted changes, replying to comments, and preparing for re-validation.
+
+## OUTCOME
+All PR feedback addressed with:
+- Targeted changes made for each feedback item
+- Feedback file updated with resolutions
+- PR comments replied to with explanations
+- Changes validated and ready for re-review
+
+## RULES FOR THIS PHASE
+
+### Success Criteria
+Read `registry/rules/agent-success-criteria.md` via `get_fraim_file` for the complete framework. Focus especially on:
+- **Integrity** (document all changes made)
+- **Correctness** (address feedback accurately)
+- **Completeness** (address every UNADDRESSED item)
+
+### Simplicity Principles
+Read `registry/rules/simplicity.md` via `get_fraim_file` for complete guidelines. Critical for feedback phase:
+- **Targeted Changes**: Make minimal changes to address specific feedback
+- **Manual Validation**: Test changes manually before updating PR
+- **Clear Communication**: Reply to each comment with clear explanations
+
+## PRINCIPLES
+- **Feedback-Driven**: Address only the specific issues raised in PR comments
+- **Minimal Changes**: Avoid scope creep or unnecessary refactoring
+- **Clear Communication**: Explain resolutions clearly to reviewers
+- **Validation**: Ensure changes work before updating PR
+
+## 📋 WORKFLOW
+
+### Step 1: Read PR Feedback File
+
+**MANDATORY**: Read the feedback file created by `wait-for-pr-review`:
+- File location: `docs/evidence/{issue_number}-{workflow_type}-feedback.md`
+- Identify all UNADDRESSED feedback items
+- Understand the context and requirements for each item
+
+### Step 2: Address Each Feedback Item
+
+**For each UNADDRESSED item:**
+
+1. **Understand the Feedback**:
+   - Read the comment carefully
+   - Identify what specific change is requested
+   - Determine the scope of the change needed
+
+2. **Make Targeted Changes**:
+   - Make minimal, focused changes to address the specific feedback
+   - Avoid unrelated changes or improvements
+   - Keep changes as small as possible while fully addressing the feedback
+
+3. **Update Feedback File**:
+   - Change status from UNADDRESSED to ADDRESSED
+   - Document your resolution approach
+   - Include details of what you changed
+
+**Feedback File Update Format**:
+```markdown
+### Comment X - ADDRESSED
+- **Author**: reviewer_name
+- **Type**: pr_comment|review_comment|review
+- **File**: file_path (if applicable)
+- **Line**: line_number (if applicable)
+- **Comment**: Original feedback text
+- **Status**: ADDRESSED
+- **Resolution**: Detailed explanation of how you addressed this feedback
+- **Changes Made**: Specific files/lines modified
+```
+
+### Step 3: Validate Changes
+
+**Test your changes:**
+- Run compilation check: `npx tsc --noEmit --skipLibCheck`
+- Run relevant tests to ensure no regressions
+- Test manually if the feedback involves UI/API behavior
+- Verify the specific issue mentioned in feedback is resolved
+
+### Step 4: Reply to PR Comments
+
+**For each addressed comment:**
+- Reply to the original PR comment
+- Explain what you changed and how it addresses their concern
+- Reference specific files/lines if helpful
+- Be clear and professional in your communication
+
+**Example reply format**:
+```
+✅ **Addressed**: [Brief description of what you changed]
+
+**Changes made**:
+- [Specific change 1]
+- [Specific change 2]
+
+**Files modified**: `path/to/file.ts`, `path/to/test.ts`
+
+This should resolve the [specific issue mentioned]. Please let me know if you need any clarification!
+```
+
+### Step 5: Commit and Push Changes
+
+**Commit your changes:**
+- Use clear commit messages that reference the feedback
+- Example: `Address PR feedback: Fix error handling in auth service`
+- Push changes to the PR branch
+
+## 📸 EVIDENCE REQUIREMENTS
+
+You MUST provide concrete evidence for all claims:
+
+1. **All Feedback Addressed**: Every UNADDRESSED item in feedback file is now ADDRESSED
+2. **Changes Made**: Specific code changes made for each feedback item
+3. **Validation Complete**: Tests pass and changes work as expected
+4. **PR Updated**: Changes committed, pushed, and comments replied to
+
+## VALIDATION
+
+### Phase Complete When:
+- ✅ All UNADDRESSED items in feedback file are now ADDRESSED
+- ✅ Feedback file updated with resolution details for each item
+- ✅ Targeted changes made to address each specific feedback
+- ✅ Changes validated (compilation, tests, manual testing)
+- ✅ PR comments replied to with clear explanations
+- ✅ Changes committed and pushed to PR branch
+
+### Phase Incomplete If:
+- ❌ Any UNADDRESSED items remain in feedback file
+- ❌ Changes don't actually address the feedback given
+- ❌ Tests failing after changes
+- ❌ Compilation errors introduced
+- ❌ PR comments not replied to
+- ❌ Changes not committed/pushed
+
+### Report Back:
+When you complete this phase, call:
+
+```javascript
+seekCoachingOnNextStep({
+  workflowType: "{workflow_type}",
+  issueNumber: "{issue_number}",
+  currentPhase: "address-pr-feedback",
+  status: "complete",
+  findings: {
+    feedbackItemsAddressed: {total_items_addressed},
+    changesValidated: true
+  },
+  evidence: {
+    feedbackFileUpdated: "All UNADDRESSED items now ADDRESSED with resolutions",
+    changesMade: "Brief summary of changes made",
+    validationResults: "Compilation and tests pass",
+    prCommentsReplied: "Replied to all PR comments with explanations"
+  }
+})
+```
+
+If feedback addressing incomplete, iterate:
+```javascript
+seekCoachingOnNextStep({
+  workflowType: "{workflow_type}",
+  issueNumber: "{issue_number}",
+  currentPhase: "address-pr-feedback",
+  status: "incomplete",
+  findings: {
+    uncertainties: ["Issues encountered", "What needs to be fixed"]
+  }
+})
+```
+
+## SCRIPTS
+
+**Compile TypeScript:**
+```bash
+npx tsc --noEmit --skipLibCheck
+```
+
+**Run tests:**
+```bash
+npm test
+```
+
+**Check git status:**
+```bash
+git status
+git diff
+```

package/dist/src/ai-manager/phase-flow.js

@@ -61,6 +61,25 @@ const TEST_PHASE_FLOW = [
  * @returns Next phase or null if at end of workflow
  */
 function getNextPhase(currentPhase, workflowType, issueType) {
+    // Special handling for address-pr-feedback phase
+    if (currentPhase === 'address-pr-feedback') {
+        // Success path: After addressing feedback, go back to appropriate validation phase
+        if (workflowType === 'implement') {
+            return 'implement-validate';
+        }
+        else if (workflowType === 'spec') {
+            return 'spec-completeness-review';
+        }
+        else if (workflowType === 'design') {
+            return 'design-completeness-review';
+        }
+        else if (workflowType === 'test') {
+            return 'test-validate';
+        }
+        else {
+            throw new Error(`Unknown workflow type: ${workflowType}`);
+        }
+    }
     let flow;
     if (workflowType === 'implement') {
         if (!issueType) {
@@ -121,10 +140,11 @@ function isPhaseValidForWorkflow(phase, workflowType, issueType) {
  * Get the phase to return to when a phase fails
  * @param failedPhase - The phase that failed
  * @param workflowType - Type of workflow
- * @param issueType - Type of issue (only used for implement workflow)
+ * @param issueType - Type of issue (currently unused - failure handling is the same for bug/feature)
  * @returns Phase to return to
  */
-function getPhaseOnFailure(failedPhase, workflowType, issueType) {
+function getPhaseOnFailure(failedPhase, workflowType, issueType // eslint-disable-line @typescript-eslint/no-unused-vars
+) {
     if (workflowType === 'implement') {
         // Implement workflow failure handling
         switch (failedPhase) {
@@ -147,9 +167,11 @@ function getPhaseOnFailure(failedPhase, workflowType, issueType) {
             case 'submit-pr':
                 return 'implement-completeness-review'; // PR submission issues, review completeness
             case 'wait-for-pr-review':
-                // This phase determines where to go based on PR comment analysis
-                // Will be handled by the PR comment analysis logic
-                return 'implement-code'; // Default fallback for PR feedback
+                // PR feedback should go to address-pr-feedback phase
+                return 'address-pr-feedback';
+            case 'address-pr-feedback':
+                // If addressing PR feedback fails, retry the same phase
+                return 'address-pr-feedback';
             default:
                 return 'implement-code'; // Default fallback
         }
@@ -164,7 +186,9 @@ function getPhaseOnFailure(failedPhase, workflowType, issueType) {
             case 'submit-pr':
                 return 'spec-completeness-review';
             case 'wait-for-pr-review':
-                return 'spec-spec'; // PR feedback usually means spec changes needed
+                return 'address-pr-feedback'; // PR feedback goes to address phase
+            case 'address-pr-feedback':
+                return 'address-pr-feedback'; // Retry addressing feedback
             default:
                 return 'spec-spec';
         }
@@ -179,7 +203,9 @@ function getPhaseOnFailure(failedPhase, workflowType, issueType) {
             case 'submit-pr':
                 return 'design-completeness-review';
             case 'wait-for-pr-review':
-                return 'design-design'; // PR feedback usually means design changes needed
+                return 'address-pr-feedback'; // PR feedback goes to address phase
+            case 'address-pr-feedback':
+                return 'address-pr-feedback'; // Retry addressing feedback
             default:
                 return 'design-design';
         }
@@ -194,7 +220,9 @@ function getPhaseOnFailure(failedPhase, workflowType, issueType) {
             case 'submit-pr':
                 return 'test-validate';
             case 'wait-for-pr-review':
-                return 'test-test'; // PR feedback usually means test changes needed
+                return 'address-pr-feedback'; // PR feedback goes to address phase
+            case 'address-pr-feedback':
+                return 'address-pr-feedback'; // Retry addressing feedback
             default:
                 return 'test-test';
         }

package/dist/src/fraim/db-service.js

@@ -18,11 +18,17 @@ class FraimDbService {
         // Use fraim_ prefix for standalone server collections
         this.keysCollection = this.db.collection('fraim_api_keys');
         this.sessionsCollection = this.db.collection('fraim_telemetry_sessions');
+        this.signupsCollection = this.db.collection('fraim_website_signups');
+        this.salesCollection = this.db.collection('fraim_sales_inquiries');
         // Create indexes
         await this.keysCollection.createIndex({ key: 1 }, { unique: true });
         await this.sessionsCollection.createIndex({ sessionId: 1 }, { unique: true });
         await this.sessionsCollection.createIndex({ userId: 1 });
         await this.sessionsCollection.createIndex({ lastActive: -1 });
+        await this.signupsCollection.createIndex({ email: 1 }, { unique: true });
+        await this.signupsCollection.createIndex({ timestamp: -1 });
+        await this.salesCollection.createIndex({ email: 1 });
+        await this.salesCollection.createIndex({ timestamp: -1 });
         console.log(`✅ Connected to Fraim DB: ${dbName}`);
     }
     async createSession(session) {
@@ -82,6 +88,46 @@ class FraimDbService {
         const random = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
         return `${prefix}${random}`;
     }
+    async createWebsiteSignup(signup) {
+        if (!this.signupsCollection)
+            throw new Error('DB not connected');
+        try {
+            await this.signupsCollection.insertOne(signup);
+        }
+        catch (error) {
+            // Handle duplicate email gracefully
+            if (error.code === 11000) {
+                throw new Error('Email already registered');
+            }
+            throw error;
+        }
+    }
+    async getWebsiteSignups(limit = 100) {
+        if (!this.signupsCollection)
+            throw new Error('DB not connected');
+        return await this.signupsCollection.find({})
+            .sort({ timestamp: -1 })
+            .limit(limit)
+            .toArray();
+    }
+    async getSignupByEmail(email) {
+        if (!this.signupsCollection)
+            throw new Error('DB not connected');
+        return await this.signupsCollection.findOne({ email });
+    }
+    async createSalesInquiry(inquiry) {
+        if (!this.salesCollection)
+            throw new Error('DB not connected');
+        await this.salesCollection.insertOne(inquiry);
+    }
+    async getSalesInquiries(limit = 100) {
+        if (!this.salesCollection)
+            throw new Error('DB not connected');
+        return await this.salesCollection.find({})
+            .sort({ timestamp: -1 })
+            .limit(limit)
+            .toArray();
+    }
     async close() {
         await this.client.close();
     }

package/dist/src/fraim-mcp-server.js

@@ -226,6 +226,10 @@ class FraimMCPServer {
         next();
     }
     async versionCheck(req, res, next) {
+        // Skip version check in test environment
+        if (process.env.NODE_ENV === 'test') {
+            return next();
+        }
         // Only check for /mcp, /files routes, or root POST (MCP) where AI agents are active
         const isMcpTraffic = req.path.startsWith('/mcp') ||
             req.path.startsWith('/files') ||
@@ -277,8 +281,8 @@ class FraimMCPServer {
      * Middleware to authenticate requests via API key
      */
     async authMiddleware(req, res, next) {
-        // Skip auth for public health check and admin routes (handled by adminAuthMiddleware)
-        if (req.path === '/health' || req.path.startsWith('/admin')) {
+        // Skip auth for public health check, admin routes, website signup, and sales inquiries
+        if (req.path === '/health' || req.path.startsWith('/admin') || req.path === '/api/signup' || req.path === '/api/sales') {
             return next();
         }
         const apiKey = req.headers['x-api-key'] || req.query['api-key'];
@@ -372,12 +376,30 @@ class FraimMCPServer {
         const isActive = await this.sessionManager.updateActivity(apiKey);
         if (!isActive) {
             console.log(`⛔ Telemetry blocked request: ${req.method} ${req.path} (No Session for ${apiKey})`);
-            // Enforce Handshake
+            // Enforce Handshake with clear instructions for agents
             res.status(400).json({
                 jsonrpc: '2.0',
                 error: {
                     code: -32600,
-                    message: "⛔ Session Not Started. Please call the 'fraim_connect' tool first to register your environment and begin the session."
+                    message: `⛔ Session Not Started. REQUIRED ACTION: Call 'fraim_connect' tool first with these parameters:
+
+{
+  "agent": {
+    "name": "YourAgentName", 
+    "model": "your-model-name"
+  },
+  "machine": {
+    "hostname": "use os.hostname()",
+    "platform": "use process.platform"
+  },
+  "repo": {
+    "url": "git remote URL",
+    "owner": "repo owner",
+    "name": "repo name"
+  }
+}
+
+After successful fraim_connect, all other FRAIM tools will work. This is required for telemetry and session management.`
                 },
                 id: req.body?.id || null
             });
@@ -510,6 +532,13 @@ class FraimMCPServer {
                         else if (pathLower.includes('script') || normalizedPath.startsWith('scripts/') || normalizedPath.startsWith('fraim/scripts/')) {
                             type = 'script';
                         }
+                        else if (normalizedPath.includes('ai-manager-rules/') && normalizedPath.includes('-phases/')) {
+                            type = 'phase';
+                            const parts = normalizedPath.split('/');
+                            if (parts.length > 2) {
+                                category = parts[parts.length - 2]; // e.g., 'implement-phases', 'spec-phases'
+                            }
+                        }
                         // Extract keywords from filename
                         const keywords = this.extractKeywords(entry.name, normalizedPath);
                         const metadata = {
@@ -768,6 +797,120 @@ class FraimMCPServer {
             const success = await this.dbService.revokeApiKey(key);
             res.json({ revoked: success });
         });
+        // Website signup endpoint (public, no auth required)
+        this.app.post('/api/signup', async (req, res) => {
+            try {
+                const { email, company, useCase, source } = req.body;
+                if (!email) {
+                    return res.status(400).json({ error: 'Email is required' });
+                }
+                // Basic email validation
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                if (!emailRegex.test(email)) {
+                    return res.status(400).json({ error: 'Invalid email format' });
+                }
+                // Get client IP and user agent for analytics
+                const ipAddress = req.ip || req.connection.remoteAddress || req.headers['x-forwarded-for'];
+                const userAgent = req.headers['user-agent'];
+                const signup = {
+                    email: email.toLowerCase().trim(),
+                    company: company?.trim() || undefined,
+                    useCase: useCase || undefined,
+                    source: source || 'website',
+                    timestamp: new Date(),
+                    ipAddress,
+                    userAgent
+                };
+                await this.dbService.createWebsiteSignup(signup);
+                console.log(`✅ New website signup: ${email} (${company || 'No company'}) - ${useCase || 'No use case'}`);
+                res.json({
+                    success: true,
+                    message: 'Successfully joined the waitlist!'
+                });
+            }
+            catch (error) {
+                console.error('❌ Website signup error:', error);
+                if (error.message === 'Email already registered') {
+                    return res.status(409).json({
+                        error: 'Email already registered',
+                        message: 'This email is already on our waitlist.'
+                    });
+                }
+                res.status(500).json({
+                    error: 'Internal server error',
+                    message: 'Failed to process signup. Please try again.'
+                });
+            }
+        });
+        // Sales inquiry endpoint (public, no auth required)
+        this.app.post('/api/sales', async (req, res) => {
+            try {
+                const { email, company, projectDetails, teamSize, timeline, budget, source } = req.body;
+                if (!email || !company || !projectDetails) {
+                    return res.status(400).json({
+                        error: 'Missing required fields',
+                        message: 'Email, company, project details are required'
+                    });
+                }
+                // Basic email validation
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                if (!emailRegex.test(email)) {
+                    return res.status(400).json({ error: 'Invalid email format' });
+                }
+                // Get client IP and user agent for analytics
+                const ipAddress = req.ip || req.connection.remoteAddress || req.headers['x-forwarded-for'];
+                const userAgent = req.headers['user-agent'];
+                const inquiry = {
+                    email: email.toLowerCase().trim(),
+                    company: company.trim(),
+                    projectDetails: projectDetails.trim(),
+                    teamSize: teamSize?.trim() || undefined,
+                    timeline: timeline?.trim() || undefined,
+                    budget: budget?.trim() || undefined,
+                    source: source || 'website',
+                    timestamp: new Date(),
+                    ipAddress,
+                    userAgent
+                };
+                await this.dbService.createSalesInquiry(inquiry);
+                console.log(`💼 New sales inquiry: ${email} from ${company} - Team: ${teamSize}`);
+                res.json({
+                    success: true,
+                    message: 'Sales inquiry submitted successfully! We\'ll be in touch soon.'
+                });
+            }
+            catch (error) {
+                console.error('❌ Sales inquiry error:', error);
+                res.status(500).json({
+                    error: 'Internal server error',
+                    message: 'Failed to process sales inquiry. Please try again.'
+                });
+            }
+        });
+        // Get signups endpoint (admin only)
+        this.app.get('/admin/signups', async (req, res) => {
+            try {
+                const limit = parseInt(req.query.limit) || 100;
+                const signups = await this.dbService.getWebsiteSignups(limit);
+                res.json({ signups, total: signups.length });
+            }
+            catch (error) {
+                console.error('❌ Failed to get signups:', error);
+                res.status(500).json({ error: 'Failed to retrieve signups' });
+            }
+        });
+        // Get sales inquiries endpoint (admin only)
+        this.app.get('/admin/sales', async (req, res) => {
+            try {
+                const limit = parseInt(req.query.limit) || 100;
+                const inquiries = await this.dbService.getSalesInquiries(limit);
+                res.json({ inquiries, total: inquiries.length });
+            }
+            catch (error) {
+                console.error('❌ Failed to get sales inquiries:', error);
+                res.status(500).json({ error: 'Failed to retrieve sales inquiries' });
+            }
+        });
         // MCP endpoint - POST for actual MCP requests
         // Handle MCP requests on both /mcp (standard) and / (easier config)
         this.app.post(['/', '/mcp'], async (req, res) => {
@@ -868,12 +1011,22 @@ Call this before fetching any workflow or file to understand the system.`,
                 },
                 {
                     name: 'fraim_connect',
-                    description: `Handshake to start a FRAIM session. MUST be called at the start of every session.
+                    description: `🚨 REQUIRED FIRST CALL: Handshake to start a FRAIM session. MUST be called at the start of every session.
+
+⚠️ CRITICAL: If you get a "Session Not Started" error from any FRAIM tool, call this tool first.
+
 Registers your environment (machine/repo/agent) for telemetry and unlocks other tools.
 
 **Agent Information**: REQUIRED - Provide your actual agent name and model (validated against known agents).
 **Machine Information**: Use os.hostname() and process.platform - required for telemetry.
-**Repository Information**: FRAIM will auto-detect from .fraim/config.json if available, or provide git remote URL.`,
+**Repository Information**: Extract and send this information from .fraim/config.json.
+
+Example call:
+{
+  "agent": {"name": "Claude", "model": "claude-3.5-sonnet"},
+  "machine": {"hostname": "my-machine", "platform": "darwin"},
+  "repo": {"url": "https://github.com/owner/repo", "owner": "owner", "name": "repo"}
+}`,
                     inputSchema: {
                         type: 'object',
                         properties: {

package/dist/tests/test-pr-review-workflow.js

@@ -43,9 +43,9 @@ async function testPRReviewFailureHandling() {
         // Test submit-pr failure
         const submitPRFailure = (0, phase_flow_js_1.getPhaseOnFailure)('submit-pr', 'implement', 'bug');
         node_assert_1.strict.equal(submitPRFailure, 'implement-completeness-review', 'submit-pr failure should return to completeness-review');
-        // Test wait-for-pr-review failure (default)
+        // Test wait-for-pr-review failure (should go to address-pr-feedback)
         const waitPRFailure = (0, phase_flow_js_1.getPhaseOnFailure)('wait-for-pr-review', 'implement', 'bug');
-        node_assert_1.strict.equal(waitPRFailure, 'implement-code', 'wait-for-pr-review failure should default to implement-code');
+        node_assert_1.strict.equal(waitPRFailure, 'address-pr-feedback', 'wait-for-pr-review failure should go to address-pr-feedback');
         // Test all workflow types have new phases
         const specPhases = (0, phase_flow_js_1.getPhasesForWorkflow)('spec');
         (0, node_assert_1.strict)(specPhases.includes('submit-pr'), 'Spec workflow should include submit-pr');
@@ -191,10 +191,14 @@ async function testRealWorldPRReviewScenario() {
         node_assert_1.strict.equal(finalPhase, null, 'wait-for-pr-review should be final phase when approved');
         // Test PR review with changes requested (failure scenario)
         const failurePhase = (0, phase_flow_js_1.getPhaseOnFailure)('wait-for-pr-review', workflowType, issueType);
-        node_assert_1.strict.equal(failurePhase, 'implement-code', 'PR changes requested should route to implement-code by default');
-        // Test iteration: after fixing code, go through validation again
-        let iterationPhase = 'implement-code';
-        const iterationFlow = ['implement-validate', 'implement-smoke', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review'];
+        node_assert_1.strict.equal(failurePhase, 'address-pr-feedback', 'PR changes requested should route to address-pr-feedback');
+        // Test iteration: after addressing feedback, go through validation again
+        let iterationPhase = 'address-pr-feedback';
+        // After addressing feedback, should go to validation phase
+        const nextAfterFeedback = (0, phase_flow_js_1.getNextPhase)(iterationPhase, workflowType, issueType);
+        node_assert_1.strict.equal(nextAfterFeedback, 'implement-validate', 'After address-pr-feedback should go to implement-validate');
+        iterationPhase = nextAfterFeedback;
+        const iterationFlow = ['implement-smoke', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review'];
         for (const expectedNext of iterationFlow) {
             const nextPhase = (0, phase_flow_js_1.getNextPhase)(iterationPhase, workflowType, issueType);
             node_assert_1.strict.equal(nextPhase, expectedNext, `Iteration: after ${iterationPhase} should go to ${expectedNext}`);

package/dist/tests/test-session-rehydration.js

@@ -92,7 +92,11 @@ async function testRehydrationAndExemptions() {
             params: {
                 name: 'fraim_connect',
                 arguments: {
-                    machine: { hostname: 'repro-host' },
+                    agent: {
+                        name: 'Claude',
+                        model: 'test-model'
+                    },
+                    machine: { hostname: 'repro-host', platform: 'test' },
                     repo: { url: 'http://github.com/repro' }
                 }
             }

package/dist/tests/test-telemetry.js

@@ -94,6 +94,10 @@ async function testTelemetryFlow() {
             params: {
                 name: 'fraim_connect',
                 arguments: {
+                    agent: {
+                        name: 'Claude',
+                        model: 'test-model'
+                    },
                     machine: { hostname: 'test-host', platform: 'test-os' },
                     repo: { url: 'http://github.com/test/repo' }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.48",
+  "version": "2.0.49",
   "description": "FRAIM v2: Framework for Rigor-based AI Management - Transform from solo developer to AI manager orchestrating production-ready code with enterprise-grade discipline",
   "main": "index.js",
   "bin": {
@@ -15,8 +15,10 @@
     "test": "node scripts/test-with-server.js",
     "start:fraim": "tsx src/fraim-mcp-server.ts",
     "dev:fraim": "tsx --watch src/fraim-mcp-server.ts",
+    "serve:website": "node fraim-pro/serve.js",
     "watch:fraimlogs": "tsx scripts/watch-fraim-logs.ts",
     "manage-keys": "tsx scripts/fraim/manage-keys.ts",
+    "view-signups": "tsx scripts/view-signups.ts",
     "fraim:init": "npm run build && node bin/fraim.js init",
     "fraim:sync": "node bin/fraim.js sync",
     "postinstall": "fraim sync || echo 'FRAIM setup skipped.'",

package/registry/scripts/create-website-structure.js

@@ -10,7 +10,21 @@
 const fs = require('fs');
 const path = require('path');
 
-function createWebsiteStructure(projectName, outputDir = '.') {
+// Read configuration from .fraim/config.json if available
+function loadConfig() {
+    const configPath = path.join(process.cwd(), '.fraim', 'config.json');
+    if (fs.existsSync(configPath)) {
+        try {
+            return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        } catch (error) {
+            console.warn('Warning: Could not parse .fraim/config.json, using defaults');
+            return {};
+        }
+    }
+    return {};
+}
+
+function createWebsiteStructure(projectName, outputDir = process.cwd()) {
     const websiteDir = path.join(outputDir, projectName);
     
     // Create main directory
@@ -531,9 +545,10 @@ Thumbs.db
 
 // CLI usage
 if (require.main === module) {
+    const config = loadConfig();
     const args = process.argv.slice(2);
     const projectName = args[0];
-    const outputDir = args[1] || '.';
+    const outputDir = args[1] || process.cwd();
     
     if (!projectName) {
         console.log('Usage: node create-website-structure.js <project-name> [output-directory]');

package/registry/scripts/profile-server.ts

@@ -3,6 +3,7 @@
 import { execSync } from 'child_process';
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
+import * as path from 'path';
 
 /**
  * Production Server Profiler

package/registry/stubs/workflows/compliance/soc2-evidence-generator.md

@@ -0,0 +1,11 @@
+# FRAIM Workflow: soc2-evidence-generator
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
+> To load the full context (rules, templates, and execution steps), ask your AI agent to:
+> `@fraim get_fraim_workflow("soc2-evidence-generator")`
+>
+> DO NOT EXECUTE.
+
+## Intent
+Generate comprehensive SOC2 compliance evidence packages by automatically collecting, documenting, and formatting evidence from project systems to demonstrate adherence to Trust Service Criteria during annual audits.

package/registry/stubs/workflows/learning/build-skillset.md

@@ -0,0 +1,11 @@
+# FRAIM Workflow: build-skillset
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
+> To load the full context (rules, templates, and execution steps), ask your AI agent to:
+> `@fraim get_fraim_workflow("build-skillset")`
+>
+> DO NOT EXECUTE.
+
+## Intent
+Create new project-specific skills through conversation with the user. This workflow allows agents to learn and document custom workflows, processes, and knowledge that are specific to the current project or team.

package/registry/stubs/workflows/legal/contract-review-analysis.md

@@ -0,0 +1,11 @@
+# FRAIM Workflow: contract-review-analysis
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
+> To load the full context (rules, templates, and execution steps), ask your AI agent to:
+> `@fraim get_fraim_workflow("contract-review-analysis")`
+>
+> DO NOT EXECUTE.
+
+## Intent
+Provide thorough, strategic legal contract review that identifies risks, strengthens protections, and optimizes business positioning. This skill enables comprehensive analysis of SOWs, NDAs, Terms & Conditions, and other legal documents to protect interests while maintaining business relationships.

package/registry/stubs/workflows/legal/saas-contract-development.md

@@ -0,0 +1,11 @@
+# FRAIM Workflow: saas-contract-development
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
+> To load the full context (rules, templates, and execution steps), ask your AI agent to:
+> `@fraim get_fraim_workflow("saas-contract-development")`
+>
+> DO NOT EXECUTE.
+
+## Intent
+Create comprehensive, legally protective contract packages for SaaS engagements including SOWs, Terms & Conditions, and strategic pricing negotiations. This skill enables rapid development of professional-grade legal documents that protect IP, limit liability, and position for business growth.