fraim-framework 2.0.63 → 2.0.65

package/dist/src/local-mcp-server/stdio-server.js

@@ -23,6 +23,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
 const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
 const axios_1 = __importDefault(require("axios"));
 class FraimLocalMCPServer {
     constructor() {
@@ -34,6 +35,7 @@ class FraimLocalMCPServer {
         this.repoInfo = null;
         this.remoteUrl = process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
         this.apiKey = process.env.FRAIM_API_KEY || '';
+        this.localVersion = this.detectLocalVersion();
         if (!this.apiKey) {
             this.logError('❌ FRAIM_API_KEY environment variable is required');
             process.exit(1);
@@ -41,13 +43,46 @@ class FraimLocalMCPServer {
         this.log('🚀 FRAIM Local MCP Server starting...');
         this.log(`📡 Remote server: ${this.remoteUrl}`);
         this.log(`🔑 API key: ${this.apiKey.substring(0, 10)}...`);
+        this.log(`Local MCP version: ${this.localVersion}`);
+        this.log(`🔍 DEBUG BUILD: Machine detection v2 active`);
     }
     log(message) {
         // Log to stderr (stdout is reserved for MCP protocol)
-        console.error(`[FRAIM] ${message}`);
+        const key = this.apiKey || 'MISSING_API_KEY';
+        console.error(`[FRAIM key:${key}] ${message}`);
+        // Also log to file for debugging
+        try {
+            const fs = require('fs');
+            const logFile = require('path').join(require('os').tmpdir(), 'fraim-mcp-proxy.log');
+            fs.appendFileSync(logFile, `${new Date().toISOString()} [${key}] ${message}\n`);
+        }
+        catch (e) {
+            // Ignore file logging errors
+        }
     }
     logError(message) {
-        console.error(`[FRAIM ERROR] ${message}`);
+        const key = this.apiKey || 'MISSING_API_KEY';
+        console.error(`[FRAIM ERROR key:${key}] ${message}`);
+    }
+    detectLocalVersion() {
+        const candidates = [
+            (0, path_1.join)(__dirname, '..', '..', '..', 'package.json'),
+            (0, path_1.join)(__dirname, '..', '..', 'package.json')
+        ];
+        for (const pkgPath of candidates) {
+            try {
+                if (!(0, fs_1.existsSync)(pkgPath))
+                    continue;
+                const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf8'));
+                if (typeof pkg.version === 'string' && pkg.version.trim().length > 0) {
+                    return pkg.version;
+                }
+            }
+            catch {
+                // Ignore and try the next candidate
+            }
+        }
+        return 'unknown';
     }
     findProjectRoot() {
         // If we already have workspace root from MCP roots, use it
@@ -64,6 +99,12 @@ class FraimLocalMCPServer {
         this.log(`   INIT_CWD: ${process.env.INIT_CWD || '(not set)'}`);
         this.log(`   HOME: ${process.env.HOME || '(not set)'}`);
         this.log(`   USERPROFILE: ${process.env.USERPROFILE || '(not set)'}`);
+        this.log(`   PWD: ${process.env.PWD || '(not set)'}`);
+        this.log(`   OLDPWD: ${process.env.OLDPWD || '(not set)'}`);
+        // Log ALL env vars that might contain workspace info
+        Object.keys(process.env).filter(k => k.toLowerCase().includes('workspace') || k.toLowerCase().includes('project') || k.toLowerCase().includes('kiro')).forEach(k => {
+            this.log(`   ${k}: ${process.env[k]}`);
+        });
         // Priority 1: Check for IDE-provided workspace environment variables
         const workspaceHints = [
             process.env.WORKSPACE_FOLDER_PATHS?.split(':')[0], // Cursor provides this (colon-separated for multi-root)
@@ -135,6 +176,7 @@ class FraimLocalMCPServer {
      */
     detectMachineInfo() {
         if (this.machineInfo) {
+            this.log(`🔄 Returning cached machine info: ${JSON.stringify(this.machineInfo)}`);
             return this.machineInfo;
         }
         try {
@@ -144,7 +186,7 @@ class FraimLocalMCPServer {
                 memory: (0, os_1.totalmem)(),
                 cpus: (0, os_1.cpus)().length
             };
-            this.log(`✅ Detected machine info: ${this.machineInfo.hostname} (${this.machineInfo.platform})`);
+            this.log(`✅ Detected machine info: ${JSON.stringify(this.machineInfo)}`);
             return this.machineInfo;
         }
         catch (error) {
@@ -475,30 +517,34 @@ class FraimLocalMCPServer {
      * Proxy request to remote FRAIM server
      */
     async proxyToRemote(request) {
+        const requestId = (0, crypto_1.randomUUID)();
         try {
             // Special handling for fraim_connect - automatically inject machine and repo info
             if (request.method === 'tools/call' && request.params?.name === 'fraim_connect') {
-                this.log('🔧 Intercepting fraim_connect to inject machine/repo info');
+                this.log(`[req:${requestId}] Intercepting fraim_connect to inject machine/repo info`);
                 const args = request.params.arguments || {};
                 // REQUIRED: Auto-detect and inject machine info
                 const detectedMachine = this.detectMachineInfo();
                 args.machine = {
-                    ...detectedMachine,
-                    ...args.machine // Allow agent to override specific fields if needed
+                    ...args.machine, // Agent values as fallback
+                    ...detectedMachine // Detected values override (always win)
                 };
-                this.log(`✅ Injected machine info: ${args.machine.hostname} (${args.machine.platform})`);
+                this.log(`[req:${requestId}] Auto-detected and injected machine info: ${JSON.stringify(args.machine)}`);
+                if (!args.machine.memory || !args.machine.cpus) {
+                    this.logError(`[req:${requestId}] WARNING: Machine info missing memory or cpus! Detected: ${JSON.stringify(detectedMachine)}, Final: ${JSON.stringify(args.machine)}`);
+                }
                 // REQUIRED: Auto-detect and inject repo info
                 const detectedRepo = this.detectRepoInfo();
                 if (detectedRepo) {
                     args.repo = {
-                        ...detectedRepo,
-                        ...args.repo // Allow agent to override specific fields if needed
+                        ...args.repo, // Agent values as fallback
+                        ...detectedRepo // Detected values override (always win)
                     };
-                    this.log(`✅ Injected repo info: ${args.repo.owner}/${args.repo.name}`);
+                    this.log(`[req:${requestId}] Auto-detected and injected repo info: ${args.repo.owner}/${args.repo.name}`);
                 }
                 else {
                     // If detection fails completely, return error instead of sending garbage
-                    this.logError('⚠️ Could not detect repo info and no config available');
+                    this.logError(`[req:${requestId}] Could not detect repo info and no config available`);
                     return {
                         jsonrpc: '2.0',
                         id: request.id,
@@ -511,23 +557,53 @@ class FraimLocalMCPServer {
                 // Update the request with injected info
                 request.params.arguments = args;
             }
+            this.log(`[req:${requestId}] Proxying ${request.method} to ${this.remoteUrl}/mcp`);
             const response = await axios_1.default.post(`${this.remoteUrl}/mcp`, request, {
                 headers: {
                     'Content-Type': 'application/json',
-                    'x-api-key': this.apiKey
+                    'x-api-key': this.apiKey,
+                    'x-fraim-request-id': requestId,
+                    'x-fraim-local-version': this.localVersion
                 },
                 timeout: 30000
             });
             return response.data;
         }
         catch (error) {
-            this.logError(`Remote request failed: ${error.message}`);
+            const status = error?.response?.status;
+            const remoteData = error?.response?.data;
+            this.logError(`[req:${requestId}] Remote request failed (${status || 'no-status'}): ${error.message}`);
+            if (remoteData && typeof remoteData === 'object') {
+                const forwarded = {
+                    jsonrpc: typeof remoteData.jsonrpc === 'string' ? remoteData.jsonrpc : '2.0',
+                    id: remoteData.id ?? request.id,
+                    error: remoteData.error ?? {
+                        code: -32603,
+                        message: `Remote server error (${status || 'unknown status'}): ${error.message}`
+                    }
+                };
+                if (forwarded.error && typeof forwarded.error === 'object') {
+                    const existingData = forwarded.error.data;
+                    forwarded.error.data = {
+                        ...(existingData && typeof existingData === 'object' ? existingData : {}),
+                        fraimRequestId: requestId,
+                        remoteStatus: status ?? null,
+                        localMcpVersion: this.localVersion
+                    };
+                }
+                return forwarded;
+            }
             return {
                 jsonrpc: '2.0',
                 id: request.id,
                 error: {
                     code: -32603,
-                    message: `Remote server error: ${error.message}`
+                    message: `Remote server error: ${error.message}`,
+                    data: {
+                        fraimRequestId: requestId,
+                        remoteStatus: status ?? null,
+                        localMcpVersion: this.localVersion
+                    }
                 }
             };
         }
@@ -575,7 +651,7 @@ class FraimLocalMCPServer {
             // Proxy initialize to remote server first
             const response = await this.proxyToRemote(request);
             const processedResponse = this.processResponse(response);
-            // After successful initialization, load config using fallback methods
+            // After successful initialization, load config
             if (!processedResponse.error) {
                 // For now, don't request roots - just use env var + upward search
                 // TODO: Implement roots/list properly after initialization is complete

package/dist/src/utils/remote-sync.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Remote Registry Sync
+ *
+ * Fetches workflows and scripts from the remote FRAIM server
+ * instead of bundling them in the npm package.
+ *
+ * Issue: #83 - Minimize client package by fetching registry remotely
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncFromRemote = syncFromRemote;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const chalk_1 = __importDefault(require("chalk"));
+const script_sync_utils_1 = require("./script-sync-utils");
+/**
+ * Sync workflows and scripts from remote FRAIM server
+ */
+async function syncFromRemote(options) {
+    const remoteUrl = options.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+    const apiKey = options.apiKey || process.env.FRAIM_API_KEY || '';
+    if (!apiKey) {
+        return {
+            success: false,
+            workflowsSynced: 0,
+            scriptsSynced: 0,
+            error: 'FRAIM_API_KEY not set'
+        };
+    }
+    try {
+        console.log(chalk_1.default.blue('🔄 Syncing from remote FRAIM server...'));
+        console.log(chalk_1.default.gray(`   Remote: ${remoteUrl}`));
+        // Fetch registry files from remote server
+        const response = await axios_1.default.get(`${remoteUrl}/api/registry/sync`, {
+            headers: {
+                'x-api-key': apiKey
+            },
+            timeout: 30000
+        });
+        const files = response.data.files || [];
+        if (!files || files.length === 0) {
+            console.log(chalk_1.default.yellow('⚠️  No files received from remote server'));
+            return {
+                success: false,
+                workflowsSynced: 0,
+                scriptsSynced: 0,
+                error: 'No files received'
+            };
+        }
+        // Sync workflows
+        const workflowFiles = files.filter(f => f.type === 'workflow');
+        const workflowsDir = (0, path_1.join)(options.projectRoot, '.fraim', 'workflows');
+        if (!(0, fs_1.existsSync)(workflowsDir)) {
+            (0, fs_1.mkdirSync)(workflowsDir, { recursive: true });
+        }
+        // Clean existing workflows
+        cleanDirectory(workflowsDir);
+        // Write workflow files
+        for (const file of workflowFiles) {
+            const filePath = (0, path_1.join)(workflowsDir, file.path);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, file.content, 'utf8');
+            console.log(chalk_1.default.gray(`  + ${file.path}`));
+        }
+        // Sync scripts to user directory
+        const scriptFiles = files.filter(f => f.type === 'script');
+        const userDir = (0, script_sync_utils_1.getUserFraimDir)();
+        const scriptsDir = (0, path_1.join)(userDir, 'scripts');
+        if (!(0, fs_1.existsSync)(scriptsDir)) {
+            (0, fs_1.mkdirSync)(scriptsDir, { recursive: true });
+        }
+        // Clean existing scripts
+        cleanDirectory(scriptsDir);
+        // Write script files
+        for (const file of scriptFiles) {
+            const filePath = (0, path_1.join)(scriptsDir, file.path);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, file.content, 'utf8');
+            console.log(chalk_1.default.gray(`  + ${file.path}`));
+        }
+        console.log(chalk_1.default.green(`\n✅ Synced ${workflowFiles.length} workflows and ${scriptFiles.length} scripts from remote`));
+        return {
+            success: true,
+            workflowsSynced: workflowFiles.length,
+            scriptsSynced: scriptFiles.length
+        };
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`❌ Remote sync failed: ${error.message}`));
+        return {
+            success: false,
+            workflowsSynced: 0,
+            scriptsSynced: 0,
+            error: error.message
+        };
+    }
+}
+/**
+ * Clean directory contents (but keep the directory itself)
+ */
+function cleanDirectory(dirPath) {
+    if (!(0, fs_1.existsSync)(dirPath))
+        return;
+    const entries = (0, fs_1.readdirSync)(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = (0, path_1.join)(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            cleanDirectory(fullPath);
+            try {
+                (0, fs_1.rmdirSync)(fullPath);
+            }
+            catch (e) {
+                // Directory not empty, skip
+            }
+        }
+        else {
+            (0, fs_1.unlinkSync)(fullPath);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.63",
+  "version": "2.0.65",
   "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": {
@@ -9,13 +9,14 @@
   },
   "scripts": {
     "dev": "tsx --watch src/fraim-mcp-server.ts > server.log 2>&1",
+    "dev:prod": "npm run build && node dist/src/fraim-mcp-server.js > server.log 2>&1",
     "build": "tsc && node scripts/copy-ai-manager-rules.js && npm run build:stubs && npm run validate:registry",
     "build:stubs": "tsx scripts/build-stub-registry.ts",
     "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",
+    "watch:fraimlogs": "tsx scripts/watch-fraim-logs.ts > prodlogs.log 2>&1",
     "manage-keys": "tsx scripts/fraim/manage-keys.ts",
     "view-signups": "tsx scripts/view-signups.ts",
     "fraim:init": "npm run build && node index.js init",
@@ -74,8 +75,6 @@
     "dist/src/cli/",
     "dist/src/fraim/",
     "dist/src/utils/",
-    "registry/stubs/",
-    "registry/scripts/",
     "bin/fraim.js",
     "bin/fraim-mcp.js",
     "index.js",

package/dist/src/utils/enforcement-utils.js

@@ -1,239 +0,0 @@
-"use strict";
-/**
- * Enforcement Utilities for FRAIM
- *
- * Provides deterministic enforcement of:
- * - Working style (PR vs Conversation)
- * - Feedback tracking requirements
- * - User config initialization
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeUserConfig = initializeUserConfig;
-exports.loadUserConfig = loadUserConfig;
-exports.getEnforcementContext = getEnforcementContext;
-exports.isCommitAllowed = isCommitAllowed;
-exports.checkUnaddressedFeedback = checkUnaddressedFeedback;
-exports.generateCommitInstructions = generateCommitInstructions;
-exports.generateFeedbackInstructions = generateFeedbackInstructions;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const child_process_1 = require("child_process");
-const script_sync_utils_js_1 = require("./script-sync-utils.js");
-const git_utils_js_1 = require("./git-utils.js");
-/**
- * Initialize user config with default values if it doesn't exist
- */
-function initializeUserConfig() {
-    try {
-        const userConfigPath = (0, path_1.join)((0, script_sync_utils_js_1.getUserFraimDir)(), 'config.json');
-        if (!(0, fs_1.existsSync)(userConfigPath)) {
-            const defaultConfig = {
-                workingStyle: 'PR' // Default to PR mode
-            };
-            // Ensure directory exists
-            const userFraimDir = (0, script_sync_utils_js_1.getUserFraimDir)();
-            if (!(0, fs_1.existsSync)(userFraimDir)) {
-                const { mkdirSync } = require('fs');
-                mkdirSync(userFraimDir, { recursive: true });
-            }
-            (0, fs_1.writeFileSync)(userConfigPath, JSON.stringify(defaultConfig, null, 2));
-        }
-    }
-    catch (error) {
-        console.warn('⚠️ Failed to initialize user config:', error);
-    }
-}
-/**
- * Load user config from ~/.fraim/config.json
- */
-function loadUserConfig() {
-    try {
-        const userConfigPath = (0, path_1.join)((0, script_sync_utils_js_1.getUserFraimDir)(), 'config.json');
-        if ((0, fs_1.existsSync)(userConfigPath)) {
-            const content = (0, fs_1.readFileSync)(userConfigPath, 'utf8');
-            return JSON.parse(content);
-        }
-    }
-    catch (error) {
-        console.warn('⚠️ Failed to load user config:', error);
-    }
-    return null;
-}
-/**
- * Get enforcement context (working style, branch info)
- */
-function getEnforcementContext(issueNumber, projectRoot) {
-    const userConfig = loadUserConfig();
-    const workingStyle = userConfig?.workingStyle || 'PR'; // Default to PR
-    let currentBranch = null;
-    let defaultBranch = null;
-    try {
-        currentBranch = (0, git_utils_js_1.getCurrentGitBranch)();
-        // Try to get default branch
-        try {
-            const remoteHead = (0, child_process_1.execSync)('git symbolic-ref refs/remotes/origin/HEAD', {
-                timeout: 2000,
-                stdio: 'pipe'
-            }).toString().trim();
-            const match = remoteHead.match(/refs\/remotes\/origin\/(.+)$/);
-            if (match) {
-                defaultBranch = match[1];
-            }
-        }
-        catch (e) {
-            defaultBranch = 'main'; // Fallback
-        }
-    }
-    catch (e) {
-        // Not a git repo or git command failed
-    }
-    return {
-        workingStyle,
-        currentBranch,
-        defaultBranch,
-        issueNumber,
-        projectRoot
-    };
-}
-/**
- * Check if agent commit is allowed based on working style
- * Note: In Conversation mode, agent NEVER commits (user commits manually)
- */
-function isCommitAllowed(context) {
-    // If Conversation style, agent NEVER commits (user commits manually)
-    if (context.workingStyle === 'Conversation') {
-        return {
-            allowed: false,
-            reason: 'Working style is "Conversation" - agent does not commit. User commits manually.'
-        };
-    }
-    // PR style: commits only allowed on feature branches, not main/master
-    if (!context.currentBranch) {
-        return {
-            allowed: false,
-            reason: 'Not in a git repository or unable to determine current branch'
-        };
-    }
-    const defaultBranch = context.defaultBranch || 'main';
-    const isDefaultBranch = context.currentBranch === defaultBranch ||
-        context.currentBranch === 'master' ||
-        context.currentBranch === 'main';
-    if (isDefaultBranch) {
-        return {
-            allowed: false,
-            reason: `Working style is "PR" but you are on ${context.currentBranch} branch. Create a feature branch first.`
-        };
-    }
-    return { allowed: true };
-}
-/**
- * Check for unaddressed feedback files
- */
-function checkUnaddressedFeedback(issueNumber, projectRoot) {
-    const feedbackFiles = [];
-    if (!projectRoot) {
-        return { hasUnaddressed: false, feedbackFiles: [] };
-    }
-    try {
-        const evidenceDir = (0, path_1.join)(projectRoot, 'docs', 'evidence');
-        if (!(0, fs_1.existsSync)(evidenceDir)) {
-            return { hasUnaddressed: false, feedbackFiles: [] };
-        }
-        const files = (0, fs_1.readdirSync)(evidenceDir);
-        const issueFeedbackPattern = new RegExp(`^${issueNumber}-.*-feedback\\.md$`);
-        for (const file of files) {
-            if (issueFeedbackPattern.test(file)) {
-                const filePath = (0, path_1.join)(evidenceDir, file);
-                const content = (0, fs_1.readFileSync)(filePath, 'utf8');
-                // Check if feedback is addressed (look for "Status: Addressed" or similar markers)
-                // Simple heuristic: if file contains "Status: Addressed" or "✅ Addressed", consider it addressed
-                // If it contains "Status: Unaddressed", it's definitely unaddressed
-                const hasUnaddressed = /status:\s*unaddressed/i.test(content);
-                const isAddressed = /status:\s*addressed|✅\s*addressed/i.test(content);
-                // If explicitly unaddressed, or if no addressed markers found at all, consider unaddressed
-                // Note: If file has both, "Unaddressed" takes precedence
-                if (hasUnaddressed || (!hasUnaddressed && !isAddressed)) {
-                    feedbackFiles.push(file);
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.warn('⚠️ Failed to check feedback files:', error);
-    }
-    return {
-        hasUnaddressed: feedbackFiles.length > 0,
-        feedbackFiles
-    };
-}
-/**
- * Generate commit behavior instructions based on working style
- */
-function generateCommitInstructions(context) {
-    // Check commit permission first (handles both Conversation and PR modes)
-    const commitCheck = isCommitAllowed(context);
-    if (context.workingStyle === 'Conversation') {
-        // Conversation mode: Agent never commits, user commits manually
-        return `\n\n**⚠️ Working Style: Conversation**\n\n` +
-            `You are in "Conversation" mode. **DO NOT commit changes**. The user will commit manually.\n\n` +
-            `**Branch Strategy**:\n` +
-            `- Work directly on ${context.defaultBranch || 'main/master'} branch\n` +
-            `- **Skip branch creation**: No need to run prep-issue.sh or create feature branches\n` +
-            `- **Skip PR creation**: Work is committed directly to ${context.defaultBranch || 'main/master'}\n\n` +
-            `**Commit Behavior**:\n` +
-            `- Make changes as requested\n` +
-            `- Do not use git commit tools\n` +
-            `- Show diff to user: "I've made these changes: [show diff]"\n` +
-            `- Suggest commit message if helpful\n` +
-            `- Wait for user to review and commit manually\n\n` +
-            `**Outcome Statements**: When documenting completion, use:\n` +
-            `- "All work ready for user review and commit" (instead of "committed to feature branch")\n` +
-            `- "Changes prepared on ${context.defaultBranch || 'main/master'} branch"\n`;
-    }
-    // PR style: Check if commits are allowed
-    if (!commitCheck.allowed) {
-        // Blocked: either on main/master or not in git repo
-        return `\n\n**⚠️ Working Style: PR**\n\n` +
-            `**BLOCKED**: ${commitCheck.reason}\n\n` +
-            `**Action Required**:\n` +
-            `1. Run prep-issue script: \`~/.fraim/scripts/prep-issue.sh ${context.issueNumber || 'ISSUE_NUMBER'}\`\n` +
-            `   OR create feature branch manually: \`git checkout -b feature/${context.issueNumber || 'issue'}-description\`\n` +
-            `2. Push branch: \`git push -u origin feature/${context.issueNumber || 'issue'}-description\`\n` +
-            `3. Then proceed with your work\n` +
-            `**DO NOT commit to ${context.currentBranch || 'main/master'} branch.**\n`;
-    }
-    // PR mode on feature branch: Commits allowed
-    return `\n\n**✅ Working Style: PR**\n\n` +
-        `You are in "PR" mode. Commits are allowed on feature branch: **${context.currentBranch}**\n\n` +
-        `**Branch Setup**:\n` +
-        `- If branch doesn't exist, run: \`~/.fraim/scripts/prep-issue.sh ${context.issueNumber || 'ISSUE_NUMBER'}\`\n` +
-        `- Confirm you're on feature branch: \`git branch --show-current\`\n\n` +
-        `**Commit Behavior**:\n` +
-        `- Create commits on this branch as you complete work\n` +
-        `- Commit message format: \`{workflow_type}({issue_number}): {description}\`\n` +
-        `- Push branch: \`git push origin ${context.currentBranch}\`\n\n` +
-        `**PR Management**:\n` +
-        `- Create PR when ready for review\n` +
-        `- **Verify PR exists** before marking work complete\n` +
-        `- Link PR to issue and add evidence document link\n\n` +
-        `**Outcome Statements**: When documenting completion, use:\n` +
-        `- "All work committed and pushed to feature branch: ${context.currentBranch}"\n`;
-}
-/**
- * Generate feedback check instructions
- */
-function generateFeedbackInstructions(issueNumber, projectRoot) {
-    const feedbackCheck = checkUnaddressedFeedback(issueNumber, projectRoot);
-    if (!feedbackCheck.hasUnaddressed) {
-        return '';
-    }
-    return `\n\n**⚠️ Unaddressed Feedback Detected**\n\n` +
-        `The following feedback files need to be addressed before proceeding:\n` +
-        feedbackCheck.feedbackFiles.map(f => `- \`docs/evidence/${f}\``).join('\n') +
-        `\n\n**Action Required**:\n` +
-        `1. Review each feedback file\n` +
-        `2. Address all feedback items\n` +
-        `3. Mark feedback as addressed in the file\n` +
-        `4. Then continue with this phase\n` +
-        `\n**DO NOT proceed until all feedback is addressed.**\n`;
-}