fraim-hub 2.0.204

package/dist/src/cli/setup/ide-detector.js

@@ -0,0 +1,383 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandPath = exports.findIDEByName = exports.getAllSupportedIDEs = exports.detectInstalledIDEs = exports.CLI_PROBE_CONFIGTYPES = exports.IDE_CONFIGS = void 0;
+exports.getAdapterConfigType = getAdapterConfigType;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+/** Returns the configType to use for adapter file filtering. Falls back to configType when adapterConfigType is not set. */
+function getAdapterConfigType(ide) {
+    return ide.adapterConfigType ?? ide.configType;
+}
+const expandPath = (filePath) => {
+    if (filePath.startsWith('~/')) {
+        return path_1.default.join(os_1.default.homedir(), filePath.slice(2));
+    }
+    return filePath;
+};
+exports.expandPath = expandPath;
+const checkMultiplePaths = (paths) => {
+    return paths.some(p => fs_1.default.existsSync(expandPath(p)));
+};
+// Issue #646 (Bug 2): a config directory left behind after uninstall (e.g. ~/.cursor,
+// ~/Library/Application Support/Cursor) made config-surface detection report Cursor
+// as "Installed" when it was not. App evidence is the reliable signal for Cursor;
+// other GUI surfaces keep their existing config-surface checks for compatibility
+// with the #640 first-run detection contract.
+const appBundlePaths = (appName) => [
+    `/Applications/${appName}.app`,
+    `~/Applications/${appName}.app`,
+];
+const windowsUserAppPaths = (appName) => {
+    switch (appName) {
+        case 'Cursor':
+            return [
+                '~/AppData/Local/Programs/Cursor/Cursor.exe',
+                '~/AppData/Local/Cursor/Cursor.exe',
+            ];
+        default:
+            return [];
+    }
+};
+// Issue #646 follow-up: a user may run a GUI app from a non-standard location
+// (e.g. straight from a mounted DMG: /Volumes/.../Cursor.app) that the
+// /Applications checks miss. A running process of the app is definitive proof it
+// is installed and in use, and a stale config dir alone has no such process — so
+// this catches real installs without re-introducing the stale-dir false positive.
+const isMacAppRunning = (appName) => {
+    if (process.platform !== 'darwin')
+        return false;
+    // Test seam: `pgrep` is system-global (not HOME-scoped), so tests that simulate
+    // "app not installed" via a temp HOME set this to keep results deterministic.
+    if (process.env.FRAIM_DETECT_DISABLE_PROCESS_CHECK === '1')
+        return false;
+    const result = (0, child_process_1.spawnSync)('pgrep', ['-f', `${appName}.app/Contents`], { encoding: 'utf8', timeout: 1500 });
+    return result.status === 0 && Boolean((result.stdout || '').trim());
+};
+const hasAppEvidence = (appName) => {
+    const evidencePaths = process.platform === 'win32'
+        ? [...appBundlePaths(appName), ...windowsUserAppPaths(appName)]
+        : appBundlePaths(appName);
+    return checkMultiplePaths(evidencePaths) || isMacAppRunning(appName);
+};
+const guiAppDetect = (configSurfaceCheck, appName, options = {}) => {
+    return () => {
+        if (options.requireAppEvidence) {
+            return hasAppEvidence(appName);
+        }
+        if (process.platform === 'darwin') {
+            return hasAppEvidence(appName);
+        }
+        return configSurfaceCheck();
+    };
+};
+const availableByVersionProbe = (command) => {
+    const result = process.platform === 'win32'
+        ? (0, child_process_1.spawnSync)('cmd.exe', ['/d', '/s', '/c', `${command} --version`], { encoding: 'utf8', timeout: 1500 })
+        : (0, child_process_1.spawnSync)(command, ['--version'], { encoding: 'utf8', timeout: 1500 });
+    return result.status === 0;
+};
+const detectClaude = () => {
+    const paths = [
+        '~/.claude.json',
+        '~/.claude',
+        '~/Library/Application Support/Cloud',
+        '~/Library/Application Support/Claude',
+        '~/AppData/Roaming/Claude'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectVSCode = () => {
+    const paths = [
+        '~/.vscode',
+        '~/Library/Application Support/Code',
+        '~/AppData/Roaming/Code',
+        '~/.config/Code'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectCursorMcpConfig = () => {
+    const paths = [
+        '~/.cursor/mcp.json',
+        '~/Library/Application Support/Cursor/mcp.json',
+        '~/AppData/Roaming/Cursor/mcp.json',
+        '~/.config/Cursor/mcp.json'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectWindsurf = () => {
+    const paths = [
+        '~/.codeium/windsurf',
+        '~/Library/Application Support/Windsurf',
+        '~/AppData/Roaming/Windsurf',
+        '~/.config/windsurf'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectGeminiCli = () => {
+    return availableByVersionProbe('gemini');
+};
+const detectCopilotCli = () => {
+    return availableByVersionProbe('copilot');
+};
+const detectGeminiSurface = () => {
+    const paths = [
+        '~/.gemini',
+        '~/.gemini/settings.json',
+        '~/AppData/Roaming/gemini/settings.json',
+        '~/.config/gemini/settings.json'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectCopilotSurface = () => {
+    const paths = [
+        process.env.COPILOT_HOME ? path_1.default.join(process.env.COPILOT_HOME, 'mcp-config.json') : '',
+        process.env.COPILOT_HOME || '',
+        '~/.copilot',
+        '~/.copilot/mcp-config.json'
+    ].filter(Boolean);
+    return detectCopilotCli() || checkMultiplePaths(paths);
+};
+const detectCodexSurface = () => {
+    const paths = [
+        '~/.codex',
+        '~/.codex/config.toml'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectGrokSurface = () => {
+    const paths = [
+        '~/.grok',
+        '~/.grok/config.toml'
+    ];
+    return checkMultiplePaths(paths);
+};
+exports.IDE_CONFIGS = [
+    {
+        name: 'Claude Code',
+        configPath: '~/.claude.json',
+        configFormat: 'json',
+        configType: 'claude-code',
+        invocationProfile: 'claude-slash',
+        detectMethod: detectClaude,
+        aliases: ['claude-code', 'claude code', 'claude code cli', 'code tab'],
+        alternativePaths: [
+            '~/.claude/settings.json'
+        ],
+        description: 'Anthropic Claude Code local surfaces (CLI and Desktop Code tab)',
+        downloadUrl: 'https://claude.ai/code',
+    },
+    {
+        name: 'Claude Desktop / Cowork',
+        configPath: process.platform === 'win32'
+            ? '~/AppData/Roaming/Claude/claude_desktop_config.json'
+            : process.platform === 'darwin'
+                ? '~/Library/Application Support/Claude/claude_desktop_config.json'
+                : '~/.config/Claude/claude_desktop_config.json',
+        configFormat: 'json',
+        configType: 'claude',
+        invocationProfile: 'launch-phrase',
+        detectMethod: guiAppDetect(detectClaude, 'Claude'),
+        aliases: ['claude', 'claude-desktop', 'claude desktop', 'claude-cowork', 'cowork', 'claude cowork'],
+        alternativePaths: [
+            '~/AppData/Roaming/Claude/claude_desktop_config.json',
+            '~/Library/Application Support/Claude/claude_desktop_config.json',
+        ],
+        description: 'Anthropic Claude Desktop chat and Cowork surfaces',
+        downloadUrl: 'https://claude.ai/download',
+    },
+    {
+        name: 'Antigravity',
+        configPath: '~/.gemini/antigravity/mcp_config.json',
+        configFormat: 'json',
+        configType: 'standard',
+        invocationProfile: 'cursor-mention',
+        detectMethod: guiAppDetect(() => fs_1.default.existsSync(expandPath('~/.gemini/antigravity')), 'Antigravity'),
+        description: 'Google Gemini Antigravity IDE',
+        downloadUrl: 'https://antigravity.google/',
+    },
+    {
+        name: 'Gemini CLI',
+        configPath: '~/.gemini/settings.json',
+        configFormat: 'json',
+        configType: 'gemini-cli',
+        invocationProfile: 'gemini-command',
+        detectMethod: detectGeminiSurface,
+        supportsConfigBootstrap: true,
+        aliases: ['gemini', 'gemini-cli', 'gemini cli'],
+        alternativePaths: [
+            '~/AppData/Roaming/gemini/settings.json',
+            '~/.config/gemini/settings.json'
+        ],
+        description: 'Google Gemini CLI local settings',
+        downloadUrl: 'https://github.com/google-gemini/gemini-cli',
+    },
+    {
+        name: 'GitHub Copilot CLI',
+        configPath: process.env.COPILOT_HOME
+            ? path_1.default.join(process.env.COPILOT_HOME, 'mcp-config.json')
+            : '~/.copilot/mcp-config.json',
+        configFormat: 'json',
+        configType: 'copilot-cli',
+        invocationProfile: 'instructions-only',
+        detectMethod: detectCopilotSurface,
+        supportsConfigBootstrap: true,
+        aliases: ['copilot', 'copilot-cli', 'github copilot', 'github copilot cli'],
+        description: 'GitHub Copilot CLI local MCP settings',
+        downloadUrl: 'https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli',
+    },
+    {
+        name: 'Kiro',
+        configPath: '~/.kiro/settings/mcp.json',
+        configFormat: 'json',
+        configType: 'kiro',
+        invocationProfile: 'kiro-hashtag',
+        detectMethod: guiAppDetect(() => fs_1.default.existsSync(expandPath('~/.kiro')), 'Kiro'),
+        description: 'Kiro AI-powered IDE',
+        downloadUrl: 'https://kiro.dev/',
+    },
+    {
+        name: 'Cursor',
+        configPath: '~/.cursor/mcp.json',
+        configFormat: 'json',
+        configType: 'kiro',
+        adapterConfigType: 'cursor',
+        invocationProfile: 'cursor-mention',
+        detectMethod: () => detectCursorMcpConfig() || hasAppEvidence('Cursor'),
+        alternativePaths: [
+            '~/Library/Application Support/Cursor/mcp.json',
+            '~/AppData/Roaming/Cursor/mcp.json',
+            '~/.config/Cursor/mcp.json'
+        ],
+        description: 'Cursor AI code editor',
+        downloadUrl: 'https://cursor.com/',
+    },
+    {
+        name: 'VSCode',
+        configPath: process.platform === 'win32'
+            ? '~/AppData/Roaming/Code/User/mcp.json'
+            : process.platform === 'darwin'
+                ? '~/Library/Application Support/Code/User/mcp.json'
+                : '~/.config/Code/User/mcp.json',
+        configFormat: 'json',
+        configType: 'vscode',
+        invocationProfile: 'vscode-prompt',
+        detectMethod: guiAppDetect(detectVSCode, 'Visual Studio Code'),
+        alternativePaths: [
+            '~/Library/Application Support/Code/User/mcp.json',
+            '~/AppData/Roaming/Code/User/mcp.json',
+            '~/.config/Code/User/mcp.json'
+        ],
+        description: 'Visual Studio Code',
+        downloadUrl: 'https://code.visualstudio.com/',
+    },
+    {
+        name: 'Codex',
+        configPath: '~/.codex/config.toml',
+        configFormat: 'toml',
+        configType: 'codex',
+        invocationProfile: 'codex-skill',
+        detectMethod: detectCodexSurface,
+        description: 'Codex AI development environment',
+        downloadUrl: 'https://github.com/openai/codex',
+    },
+    {
+        name: 'Grok',
+        configPath: '~/.grok/config.toml',
+        configFormat: 'toml',
+        configType: 'grok',
+        invocationProfile: 'grok-skill',
+        detectMethod: detectGrokSurface,
+        supportsConfigBootstrap: true,
+        aliases: ['grok', 'grok-cli', 'grok cli', 'grok build'],
+        description: 'xAI Grok Build CLI local settings',
+        downloadUrl: 'https://x.ai/grok',
+    },
+    {
+        name: 'Windsurf',
+        configPath: '~/.codeium/windsurf/mcp_config.json',
+        configFormat: 'json',
+        configType: 'windsurf',
+        invocationProfile: 'windsurf-command',
+        detectMethod: guiAppDetect(detectWindsurf, 'Windsurf'),
+        alternativePaths: [
+            '~/Library/Application Support/Windsurf/mcp_config.json',
+            '~/AppData/Roaming/Windsurf/mcp_config.json',
+            '~/.config/windsurf/mcp_config.json'
+        ],
+        description: 'Codeium Windsurf IDE',
+        downloadUrl: 'https://windsurf.com/',
+    }
+];
+const findBestConfigPath = (ide) => {
+    if (fs_1.default.existsSync(expandPath(ide.configPath))) {
+        return ide.configPath;
+    }
+    if (ide.alternativePaths) {
+        for (const altPath of ide.alternativePaths) {
+            if (fs_1.default.existsSync(expandPath(altPath))) {
+                return altPath;
+            }
+        }
+    }
+    return ide.configPath;
+};
+const _cachedIDEs = new Map();
+const _cacheTimestamps = new Map();
+const _cacheHomeDirs = new Map();
+const DETECT_CACHE_TTL_MS = 5000;
+/** configTypes that require a binary probe in cli-runnable mode; config folder alone is insufficient. */
+exports.CLI_PROBE_CONFIGTYPES = new Set(['claude-code', 'codex', 'grok', 'gemini-cli', 'copilot-cli']);
+const isDetectedForMode = (ide, mode) => {
+    if (mode === 'cli-runnable') {
+        switch (ide.configType) {
+            case 'claude-code':
+                return availableByVersionProbe('claude');
+            case 'codex':
+                return availableByVersionProbe('codex');
+            case 'grok':
+                return availableByVersionProbe('grok');
+            case 'gemini-cli':
+                return detectGeminiCli();
+            case 'copilot-cli':
+                return detectCopilotCli();
+            default:
+                return false;
+        }
+    }
+    return ide.detectMethod();
+};
+const detectInstalledIDEs = (mode = 'config-surface') => {
+    const now = Date.now();
+    const currentHome = os_1.default.homedir();
+    const cached = _cachedIDEs.get(mode);
+    const cacheTimestamp = _cacheTimestamps.get(mode) || 0;
+    const cacheHomeDir = _cacheHomeDirs.get(mode) || '';
+    if (cached !== undefined && cacheHomeDir === currentHome && (now - cacheTimestamp) < DETECT_CACHE_TTL_MS) {
+        return cached;
+    }
+    const detected = exports.IDE_CONFIGS.filter((ide) => isDetectedForMode(ide, mode)).map(ide => ({
+        ...ide,
+        configPath: findBestConfigPath(ide)
+    }));
+    _cachedIDEs.set(mode, detected);
+    _cacheTimestamps.set(mode, now);
+    _cacheHomeDirs.set(mode, currentHome);
+    return detected;
+};
+exports.detectInstalledIDEs = detectInstalledIDEs;
+const getAllSupportedIDEs = () => {
+    return exports.IDE_CONFIGS;
+};
+exports.getAllSupportedIDEs = getAllSupportedIDEs;
+const findIDEByName = (name) => {
+    const normalized = name.toLowerCase();
+    return exports.IDE_CONFIGS.find(ide => ide.name.toLowerCase().includes(normalized) ||
+        normalized.includes(ide.name.toLowerCase()) ||
+        ide.aliases?.some(alias => alias.toLowerCase().includes(normalized) || normalized.includes(alias.toLowerCase())));
+};
+exports.findIDEByName = findIDEByName;

package/dist/src/cli/setup/ide-global-integration.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeConfiguredInvocationSurfaces = describeConfiguredInvocationSurfaces;
+exports.describeOnboardingInvocationSurfaces = describeOnboardingInvocationSurfaces;
+exports.installSlashCommands = installSlashCommands;
+exports.installGlobalRules = installGlobalRules;
+/**
+ * IDE Global Integration
+ *
+ * Installs user-level FRAIM invocation artifacts for supported IDEs.
+ * These surfaces make FRAIM discoverable without requiring `fraim init-project`.
+ */
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const ide_invocation_surfaces_1 = require("./ide-invocation-surfaces");
+function describeConfiguredInvocationSurfaces(installedIDEs) {
+    return installedIDEs.map((ide) => (0, ide_invocation_surfaces_1.describeInvocationSurface)(ide.name, ide.invocationProfile));
+}
+// Returns IDE-specific onboarding commands for the post-setup routing screen.
+// Maps each IDE's invocation prefix to the project-onboarding task string so
+// the user sees the exact command to type, not a generic FRAIM invocation.
+function describeOnboardingInvocationSurfaces(installedIDEs) {
+    if (installedIDEs.length === 0)
+        return ['/fraim onboard this project'];
+    return installedIDEs.map((ide) => {
+        const profile = ide.invocationProfile;
+        if (profile === 'cursor-mention')
+            return `${ide.name}: @fraim onboard this project`;
+        if (profile === 'launch-phrase')
+            return `${ide.name}: onboard this project`;
+        if (profile === 'instructions-only')
+            return `${ide.name}: "onboard this project"`;
+        // claude-slash, vscode-prompt, codex-skill, grok-skill, windsurf-command, kiro-hashtag, gemini-command
+        return `${ide.name}: /fraim onboard this project`;
+    });
+}
+/**
+ * Install Claude FRAIM discovery artifacts at the user level.
+ * Writes a skill to ~/.claude/skills/fraim/SKILL.md and a compatibility command
+ * to ~/.claude/commands/fraim.md. Existing user files are preserved.
+ */
+async function installSlashCommands(homeDir) {
+    const home = homeDir || os_1.default.homedir();
+    const claudeDir = path_1.default.join(home, '.claude');
+    if (!fs_1.default.existsSync(claudeDir)) {
+        return;
+    }
+    installFileIfMissing(path_1.default.join(claudeDir, 'skills', 'fraim', 'SKILL.md'), (0, ide_invocation_surfaces_1.buildClaudeSkillContent)(), 'Claude FRAIM skill (~/.claude/skills/fraim/SKILL.md)');
+    installFileIfMissing(path_1.default.join(claudeDir, 'commands', 'fraim.md'), (0, ide_invocation_surfaces_1.buildClaudeCommandShimContent)(), 'Claude compatibility command (~/.claude/commands/fraim.md)');
+}
+/**
+ * Install FRAIM invocation artifacts for non-Claude IDEs.
+ * Supports: Cursor, Codex, Grok, Gemini CLI, Copilot CLI, Windsurf, Kiro
+ * Does not overwrite existing files.
+ */
+async function installGlobalRules(homeDir) {
+    const home = homeDir || os_1.default.homedir();
+    const cursorDir = path_1.default.join(home, '.cursor');
+    if (fs_1.default.existsSync(cursorDir)) {
+        installFileIfMissing(path_1.default.join(cursorDir, 'rules', 'fraim.mdc'), (0, ide_invocation_surfaces_1.buildCursorMentionRuleContent)(), 'Cursor FRAIM rule (~/.cursor/rules/fraim.mdc)');
+    }
+    const codexDir = path_1.default.join(home, '.codex');
+    if (fs_1.default.existsSync(codexDir)) {
+        installFileIfMissing(path_1.default.join(codexDir, 'skills', 'fraim', 'SKILL.md'), (0, ide_invocation_surfaces_1.buildCodexSkillContent)(), 'Codex FRAIM skill (~/.codex/skills/fraim/SKILL.md)');
+    }
+    const grokDir = path_1.default.join(home, '.grok');
+    if (fs_1.default.existsSync(grokDir)) {
+        installFileIfMissing(path_1.default.join(grokDir, 'skills', 'fraim', 'SKILL.md'), (0, ide_invocation_surfaces_1.buildGrokSkillContent)(), 'Grok FRAIM skill (~/.grok/skills/fraim/SKILL.md)');
+    }
+    const geminiDir = path_1.default.join(home, '.gemini');
+    if (fs_1.default.existsSync(geminiDir)) {
+        installFileIfMissing(path_1.default.join(geminiDir, 'commands', 'fraim.toml'), (0, ide_invocation_surfaces_1.buildGeminiCommandContent)(), 'Gemini CLI FRAIM command (~/.gemini/commands/fraim.toml)');
+    }
+    const antigravityDir = path_1.default.join(home, '.gemini', 'antigravity');
+    if (fs_1.default.existsSync(antigravityDir)) {
+        installFileIfMissing(path_1.default.join(antigravityDir, 'commands', 'fraim.md'), (0, ide_invocation_surfaces_1.buildAntigravityCommandContent)(), 'Antigravity FRAIM command (~/.gemini/antigravity/commands/fraim.md)');
+    }
+    const windsurfDir = path_1.default.join(home, '.codeium', 'windsurf');
+    if (fs_1.default.existsSync(windsurfDir)) {
+        installFileIfMissing(path_1.default.join(windsurfDir, 'commands', 'fraim.md'), (0, ide_invocation_surfaces_1.buildWindsurfCommandContent)(), 'Windsurf FRAIM command (~/.codeium/windsurf/commands/fraim.md)');
+    }
+    const kiroDir = path_1.default.join(home, '.kiro');
+    if (fs_1.default.existsSync(kiroDir)) {
+        installFileIfMissing(path_1.default.join(kiroDir, 'commands', 'fraim.md'), (0, ide_invocation_surfaces_1.buildKiroCommandContent)(), 'Kiro FRAIM command (~/.kiro/commands/fraim.md)');
+    }
+}
+function installFileIfMissing(filePath, content, displayName) {
+    if (fs_1.default.existsSync(filePath)) {
+        console.log(chalk_1.default.gray(`   ${displayName.split('(')[0].trim()} already exists — skipping`));
+        return;
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+    fs_1.default.writeFileSync(filePath, content, 'utf8');
+    console.log(chalk_1.default.green(`   ✅ Installed ${displayName}`));
+}

package/dist/src/cli/setup/ide-invocation-surfaces.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRAIM_INVOCATION_BODY = exports.FRAIM_DEFERRED_TOOL_PRELOAD = exports.CURSOR_MDC_FRONTMATTER = exports.FRAIM_LAUNCH_PHRASE = void 0;
+exports.buildFraimInvocationBody = buildFraimInvocationBody;
+exports.buildClaudeSkillContent = buildClaudeSkillContent;
+exports.buildClaudeCommandShimContent = buildClaudeCommandShimContent;
+exports.buildClaudeSlashCommandContent = buildClaudeSlashCommandContent;
+exports.buildCursorMentionRuleContent = buildCursorMentionRuleContent;
+exports.buildCodexSkillContent = buildCodexSkillContent;
+exports.buildGrokSkillContent = buildGrokSkillContent;
+exports.buildWindsurfCommandContent = buildWindsurfCommandContent;
+exports.buildKiroCommandContent = buildKiroCommandContent;
+exports.buildAntigravityCommandContent = buildAntigravityCommandContent;
+exports.buildGeminiCommandContent = buildGeminiCommandContent;
+exports.describeInvocationSurface = describeInvocationSurface;
+exports.FRAIM_LAUNCH_PHRASE = 'Use FRAIM for <job or task>';
+exports.CURSOR_MDC_FRONTMATTER = `---
+description: FRAIM discovery and execution contract
+alwaysApply: true
+---`;
+exports.FRAIM_DEFERRED_TOOL_PRELOAD = [
+    'fraim_connect',
+    'list_fraim_jobs',
+    'get_fraim_job',
+    'get_fraim_file',
+    'seekMentoring'
+];
+function buildDeferredToolBootstrapSection(profile) {
+    if (profile === 'none') {
+        return '';
+    }
+    const preloadList = exports.FRAIM_DEFERRED_TOOL_PRELOAD.map((toolName) => `\`${toolName}\``).join(', ');
+    switch (profile) {
+        case 'claude-toolsearch':
+            return `0. **Preload deferred FRAIM tools when needed**:
+   - If FRAIM MCP tools are unavailable because this host lazily loads deferred tool schemas, call \`ToolSearch\` once to load ${preloadList}.
+   - Do the preload as one batched discovery step, not one search per tool.
+
+`;
+        case 'codex-tool-search':
+            return `0. **Preload deferred FRAIM tools when needed**:
+   - If FRAIM MCP tools are unavailable because this host lazily loads deferred tool schemas, call \`tool_search\` once to load ${preloadList}.
+   - Do the preload as one batched discovery step, not one search per tool.
+
+`;
+        case 'generic-tool-discovery':
+            return `0. **Preload deferred FRAIM tools when needed**:
+   - If FRAIM MCP tools are unavailable because this host lazily loads deferred tool schemas, use the host's tool discovery surface once to load ${preloadList}.
+   - Do the preload as one batched discovery step, not one search per tool.
+
+`;
+        default:
+            return '';
+    }
+}
+function buildFraimInvocationBody(profile = 'none') {
+    return `Follow this process:
+
+${buildDeferredToolBootstrapSection(profile)}1. **If the user did not specify a FRAIM job or topic**:
+   If local FRAIM job stubs are present in the workspace, inspect those first and match the request locally. Also inspect \`fraim/personalized-employee/jobs/\` for local overrides or repo-specific jobs. If local files are missing or you cannot inspect workspace files, call \`list_fraim_jobs()\` to view the full catalog, including any proxy-discoverable personalized jobs.
+
+2. **Find the match**:
+   Match the user's request to a FRAIM job from the local stub catalog, \`fraim/personalized-employee/jobs/\`, or the full \`list_fraim_jobs()\` response. If no job matches, try a likely FRAIM skill with \`get_fraim_file({ path: "skills/<likely-category>/<argument>.md" })\` and confirm the match with the user.
+
+3. **Load the full content**:
+   - For jobs, call \`get_fraim_job({ job: "<matched-job-name>" })\`.
+   - For skills, use the content returned by \`get_fraim_file(...)\`.
+
+4. **Execute**:
+   - For jobs, follow the phased instructions and use \`seekMentoring\` when the job requires phase transitions.
+   - For skills, apply the skill steps directly to the user's current context.
+`;
+}
+exports.FRAIM_INVOCATION_BODY = buildFraimInvocationBody();
+function buildClaudeSkillContent() {
+    return `# FRAIM
+
+${buildFraimInvocationBody('claude-toolsearch')}`;
+}
+function buildClaudeCommandShimContent() {
+    return `# FRAIM Compatibility Command
+
+Use the FRAIM skill when Claude exposes skills directly. This compatibility command keeps \`/fraim\` working on surfaces that still discover legacy command files.
+
+${buildFraimInvocationBody('claude-toolsearch')}`;
+}
+function buildClaudeSlashCommandContent() {
+    return buildClaudeCommandShimContent();
+}
+function buildCursorMentionRuleContent() {
+    return `${exports.CURSOR_MDC_FRONTMATTER}
+
+# FRAIM
+
+${buildFraimInvocationBody('generic-tool-discovery')}
+`;
+}
+function buildCodexSkillContent() {
+    return `# FRAIM
+
+${buildFraimInvocationBody('codex-tool-search')}`;
+}
+function buildGrokSkillContent() {
+    return `# FRAIM
+
+${buildFraimInvocationBody('generic-tool-discovery')}`;
+}
+function buildWindsurfCommandContent() {
+    return `# FRAIM
+
+${buildFraimInvocationBody('generic-tool-discovery')}`;
+}
+function buildKiroCommandContent() {
+    return `# FRAIM
+
+${buildFraimInvocationBody('generic-tool-discovery')}`;
+}
+function escapeTomlMultiline(value) {
+    return value.replace(/"""/g, '\\"""');
+}
+function buildAntigravityCommandContent() {
+    return `# FRAIM
+
+${buildFraimInvocationBody('generic-tool-discovery')}`;
+}
+function buildGeminiCommandContent() {
+    return `description = "Discover and execute FRAIM jobs and skills"
+prompt = """
+# FRAIM
+
+${escapeTomlMultiline(buildFraimInvocationBody('generic-tool-discovery'))}
+"""`;
+}
+function describeInvocationSurface(ideName, invocationProfile) {
+    switch (invocationProfile) {
+        case 'claude-slash':
+            return ideName === 'Claude Code'
+                ? 'Claude Code (CLI/Desktop): /fraim'
+                : `${ideName}: /fraim`;
+        case 'launch-phrase':
+            return `${ideName}: "${exports.FRAIM_LAUNCH_PHRASE}"`;
+        case 'cursor-mention':
+            return `${ideName}: @fraim`;
+        case 'vscode-prompt':
+            return `${ideName}: /fraim via workspace prompt`;
+        case 'codex-skill':
+            return `${ideName}: /fraim, $fraim`;
+        case 'grok-skill':
+            return `${ideName}: /fraim`;
+        case 'windsurf-command':
+            return `${ideName}: /fraim`;
+        case 'kiro-hashtag':
+            return `${ideName}: #fraim`;
+        case 'gemini-command':
+            return `${ideName}: /fraim`;
+        case 'instructions-only':
+        default:
+            return `${ideName}: natural language`;
+    }
+}