fraim-framework 2.0.120 → 2.0.123

package/dist/src/ai-hub/server.js

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiHubServer = void 0;
+exports.findAvailablePort = findAvailablePort;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const net_1 = __importDefault(require("net"));
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const catalog_1 = require("./catalog");
+const hosts_1 = require("./hosts");
+const preferences_1 = require("./preferences");
+class AiHubRunRegistry {
+    constructor() {
+        this.runs = new Map();
+        this.children = new Map();
+    }
+    listLatest() {
+        return [...this.runs.values()].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
+    }
+    get(runId) {
+        return this.runs.get(runId);
+    }
+    create(run, child) {
+        this.runs.set(run.id, run);
+        this.children.set(run.id, child);
+        return run;
+    }
+    update(runId, updater) {
+        const run = this.runs.get(runId);
+        if (!run) {
+            throw new Error(`Run ${runId} not found`);
+        }
+        updater(run);
+        run.updatedAt = new Date().toISOString();
+        return run;
+    }
+    dispose(runId) {
+        this.children.delete(runId);
+    }
+}
+function ensureDirectoryPath(projectPath) {
+    const trimmed = (projectPath || '').trim();
+    if (!trimmed) {
+        throw new Error('Project path is required.');
+    }
+    const resolved = path_1.default.resolve(trimmed);
+    const stat = fs_1.default.existsSync(resolved) ? fs_1.default.statSync(resolved) : null;
+    if (!stat || !stat.isDirectory()) {
+        throw new Error('Project path must point to an existing directory.');
+    }
+    return resolved;
+}
+class AiHubServer {
+    constructor(options = {}) {
+        this.app = (0, express_1.default)();
+        this.runRegistry = new AiHubRunRegistry();
+        this.projectPath = options.projectPath || process.cwd();
+        this.preferencesStore = options.preferencesStore || new preferences_1.AiHubPreferencesStore();
+        this.hostRuntime = options.hostRuntime || (process.env.FRAIM_AI_HUB_FAKE_HOST === '1' ? new hosts_1.FakeHostRuntime() : new hosts_1.CliHostRuntime());
+        this.app.use(express_1.default.json());
+        this.app.use('/ai-hub', express_1.default.static(resolveAiHubPublicDir()));
+        this.app.get('/health', (_req, res) => {
+            res.json({ status: 'ok', service: 'fraim-ai-hub' });
+        });
+        this.registerRoutes();
+    }
+    getApp() {
+        return this.app;
+    }
+    async start(port) {
+        await new Promise((resolve, reject) => {
+            this.httpServer = this.app.listen(port, '127.0.0.1');
+            this.httpServer.once('listening', () => resolve());
+            this.httpServer.once('error', (error) => reject(error));
+        });
+    }
+    async stop() {
+        if (!this.httpServer)
+            return;
+        await new Promise((resolve, reject) => {
+            this.httpServer.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+        this.httpServer = undefined;
+    }
+    bootstrapResponse(projectPath) {
+        const normalizedProjectPath = path_1.default.resolve(projectPath || this.projectPath);
+        const preferences = this.preferencesStore.load(normalizedProjectPath);
+        const project = (0, catalog_1.summarizeProject)(normalizedProjectPath);
+        const jobs = (0, catalog_1.discoverEmployeeJobs)(normalizedProjectPath);
+        const managerTemplates = (0, catalog_1.discoverManagerTemplates)(normalizedProjectPath);
+        return {
+            title: 'Visa AI Hub',
+            project,
+            preferences,
+            categories: (0, catalog_1.getAiHubCategories)(),
+            jobs,
+            managerTemplates,
+            employees: this.hostRuntime.detectEmployees(),
+            activeRun: this.runRegistry.listLatest(),
+        };
+    }
+    registerRoutes() {
+        this.app.get('/api/ai-hub/bootstrap', (req, res) => {
+            const projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.length > 0
+                ? req.query.projectPath
+                : this.projectPath;
+            res.json(this.bootstrapResponse(projectPath));
+        });
+        this.app.post('/api/ai-hub/project-path/pick', (_req, res) => {
+            try {
+                const projectPath = pickProjectPath();
+                if (!projectPath) {
+                    return res.status(204).end();
+                }
+                return res.json({ path: projectPath });
+            }
+            catch (error) {
+                return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not open the folder picker.' });
+            }
+        });
+        this.app.post('/api/ai-hub/runs', (req, res) => {
+            try {
+                const projectPath = ensureDirectoryPath(req.body.projectPath || this.projectPath);
+                const hostId = req.body.hostId;
+                const jobId = req.body.jobId;
+                const message = (req.body.message || '').trim();
+                if (hostId !== 'codex' && hostId !== 'claude') {
+                    throw new Error('Choose an available employee before starting a job.');
+                }
+                if (!jobId) {
+                    throw new Error('Choose a FRAIM job before starting a run.');
+                }
+                if (!message) {
+                    throw new Error('Coach your employee before starting the run.');
+                }
+                const employee = this.hostRuntime.detectEmployees().find((entry) => entry.id === hostId);
+                if (!employee?.available) {
+                    throw new Error(`${employee?.label || 'Selected employee'} is not available on this machine.`);
+                }
+                const run = {
+                    id: (0, crypto_1.randomUUID)(),
+                    jobId,
+                    hostId,
+                    projectPath,
+                    status: 'running',
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                    messages: [(0, hosts_1.createHubMessage)('manager', message)],
+                    events: [(0, hosts_1.createHubEvent)('system', `Starting ${hostId} in ${projectPath}`)],
+                };
+                this.runRegistry.create(run, {});
+                const child = this.hostRuntime.startRun(hostId, projectPath, message, {
+                    onEvent: (event, channel) => {
+                        this.runRegistry.update(run.id, (current) => {
+                            if (event.sessionId)
+                                current.sessionId = event.sessionId;
+                            if (event.message)
+                                current.messages.push((0, hosts_1.createHubMessage)('employee', event.message));
+                            if (event.raw)
+                                current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                        });
+                    },
+                    onExit: (exitCode) => {
+                        this.runRegistry.update(run.id, (current) => {
+                            current.exitCode = exitCode;
+                            current.status = exitCode === 0 ? 'completed' : 'failed';
+                            current.events.push((0, hosts_1.createHubEvent)('system', `Run exited with code ${exitCode ?? 'unknown'}.`));
+                        });
+                        this.runRegistry.dispose(run.id);
+                    },
+                });
+                this.runRegistry.create(run, child);
+                const existingPreferences = this.preferencesStore.load(projectPath);
+                this.preferencesStore.remember({
+                    ...existingPreferences,
+                    projectPath,
+                    employeeId: hostId,
+                    recentJobIds: existingPreferences.recentJobIds,
+                }, jobId);
+                res.status(201).json(run);
+            }
+            catch (error) {
+                res.status(400).json({ error: error instanceof Error ? error.message : 'Could not start run.' });
+            }
+        });
+        this.app.post('/api/ai-hub/runs/:runId/messages', (req, res) => {
+            try {
+                const run = this.runRegistry.get(req.params.runId);
+                if (!run) {
+                    return res.status(404).json({ error: 'Run not found.' });
+                }
+                if (!run.sessionId) {
+                    return res.status(409).json({ error: 'This run does not have a resumable host session yet.' });
+                }
+                const message = (req.body.message || '').trim();
+                if (!message) {
+                    return res.status(400).json({ error: 'Coach your employee before sending the next turn.' });
+                }
+                this.runRegistry.update(run.id, (current) => {
+                    current.status = 'running';
+                    current.messages.push((0, hosts_1.createHubMessage)('manager', message));
+                });
+                this.runRegistry.create(run, {});
+                const child = this.hostRuntime.continueRun(run.hostId, run.projectPath, run.sessionId, message, {
+                    onEvent: (event, channel) => {
+                        this.runRegistry.update(run.id, (current) => {
+                            if (event.sessionId)
+                                current.sessionId = event.sessionId;
+                            if (event.message)
+                                current.messages.push((0, hosts_1.createHubMessage)('employee', event.message));
+                            if (event.raw)
+                                current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                        });
+                    },
+                    onExit: (exitCode) => {
+                        this.runRegistry.update(run.id, (current) => {
+                            current.exitCode = exitCode;
+                            current.status = exitCode === 0 ? 'completed' : 'failed';
+                            current.events.push((0, hosts_1.createHubEvent)('system', `Run exited with code ${exitCode ?? 'unknown'}.`));
+                        });
+                        this.runRegistry.dispose(run.id);
+                    },
+                });
+                this.runRegistry.create(run, child);
+                res.json(this.runRegistry.get(run.id));
+            }
+            catch (error) {
+                res.status(400).json({ error: error instanceof Error ? error.message : 'Could not continue run.' });
+            }
+        });
+        this.app.get('/api/ai-hub/runs/:runId', (req, res) => {
+            const run = this.runRegistry.get(req.params.runId);
+            if (!run) {
+                return res.status(404).json({ error: 'Run not found.' });
+            }
+            return res.json(run);
+        });
+    }
+}
+exports.AiHubServer = AiHubServer;
+async function findAvailablePort(preferredPort) {
+    let port = preferredPort;
+    while (port < preferredPort + 20) {
+        const available = await new Promise((resolve) => {
+            const server = net_1.default.createServer();
+            server.once('error', () => resolve(false));
+            server.once('listening', () => {
+                server.close(() => resolve(true));
+            });
+            server.listen(port, '127.0.0.1');
+        });
+        if (available)
+            return port;
+        port += 1;
+    }
+    throw new Error(`No free loopback port found near ${preferredPort}.`);
+}
+function resolveAiHubPublicDir() {
+    const candidates = [
+        path_1.default.resolve(process.cwd(), 'public/ai-hub'),
+        path_1.default.resolve(__dirname, '..', '..', 'public/ai-hub'),
+        path_1.default.resolve(__dirname, '..', '..', '..', 'public/ai-hub'),
+    ];
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error('Could not locate public/ai-hub assets.');
+}
+function pickProjectPath() {
+    if (process.platform === 'win32') {
+        const script = [
+            'Add-Type -AssemblyName System.Windows.Forms',
+            '$dialog = New-Object System.Windows.Forms.FolderBrowserDialog',
+            '$dialog.ShowNewFolderButton = $false',
+            'if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {',
+            '  Write-Output $dialog.SelectedPath',
+            '}',
+        ].join('; ');
+        const result = (0, child_process_1.spawnSync)('powershell', ['-NoProfile', '-Command', script], {
+            encoding: 'utf8',
+        });
+        return result.status === 0 ? result.stdout.trim() || null : null;
+    }
+    if (process.platform === 'darwin') {
+        const result = (0, child_process_1.spawnSync)('osascript', ['-e', 'POSIX path of (choose folder with prompt "Select a FRAIM project folder")'], {
+            encoding: 'utf8',
+        });
+        return result.status === 0 ? result.stdout.trim() || null : null;
+    }
+    const result = (0, child_process_1.spawnSync)('bash', ['-lc', 'zenity --file-selection --directory 2>/dev/null || kdialog --getexistingdirectory 2>/dev/null'], {
+        encoding: 'utf8',
+    });
+    return result.status === 0 ? result.stdout.trim() || null : null;
+}

package/dist/src/ai-hub/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/cli/commands/hub.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hubCommand = void 0;
+const commander_1 = require("commander");
+const server_1 = require("../../ai-hub/server");
+const git_utils_1 = require("../../core/utils/git-utils");
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+function resolveElectronBinary() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('electron');
+    }
+    catch {
+        return null;
+    }
+}
+function resolveDesktopEntry() {
+    const candidates = [
+        path_1.default.resolve(__dirname, '..', '..', 'ai-hub', 'desktop-main.js'),
+        path_1.default.resolve(process.cwd(), 'dist', 'src', 'ai-hub', 'desktop-main.js'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            fs_1.default.accessSync(candidate);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function openDesktopWindow(projectPath, preferredPort) {
+    const electronBinary = resolveElectronBinary();
+    const desktopEntry = resolveDesktopEntry();
+    if (!electronBinary || !desktopEntry) {
+        return false;
+    }
+    const child = (0, child_process_1.spawn)(electronBinary, [desktopEntry, '--project-path', projectPath, '--port', String(preferredPort)], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    return true;
+}
+function openBrowser(url) {
+    if (process.platform === 'win32') {
+        const child = (0, child_process_1.spawn)('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' });
+        child.unref();
+        return;
+    }
+    if (process.platform === 'darwin') {
+        const child = (0, child_process_1.spawn)('open', [url], { detached: true, stdio: 'ignore' });
+        child.unref();
+        return;
+    }
+    const child = (0, child_process_1.spawn)('xdg-open', [url], { detached: true, stdio: 'ignore' });
+    child.unref();
+}
+exports.hubCommand = new commander_1.Command('hub')
+    .description('Start the Visa AI Hub local companion for running FRAIM jobs through Codex or Claude Code')
+    .option('--port <port>', 'Preferred local port for the hub', (value) => Number(value), 43091)
+    .option('--project-path <path>', 'Initial project path for job discovery', process.cwd())
+    .option('--no-open', 'Do not open the hub after startup')
+    .option('--browser', 'Open in the default browser instead of the desktop shell')
+    .action(async (options) => {
+    const preferredPort = options.port || (0, git_utils_1.getPort)() + 100;
+    const projectPath = path_1.default.resolve(options.projectPath || process.cwd());
+    if (options.open) {
+        const openedDesktop = !options.browser && openDesktopWindow(projectPath, preferredPort);
+        if (!openedDesktop) {
+            const port = await (0, server_1.findAvailablePort)(preferredPort);
+            const server = new server_1.AiHubServer({ projectPath });
+            await server.start(port);
+            const url = `http://127.0.0.1:${port}/ai-hub/`;
+            console.log(`Visa AI Hub running at ${url}`);
+            console.log(`Project path: ${projectPath}`);
+            openBrowser(url);
+            return;
+        }
+        console.log('Visa AI Hub desktop shell launched.');
+        console.log(`Project path: ${projectPath}`);
+        return;
+    }
+    const port = await (0, server_1.findAvailablePort)(preferredPort);
+    const server = new server_1.AiHubServer({ projectPath });
+    await server.start(port);
+    const url = `http://127.0.0.1:${port}/ai-hub/`;
+    console.log(`Visa AI Hub running at ${url}`);
+    console.log(`Project path: ${projectPath}`);
+});

package/dist/src/cli/commands/setup.js

@@ -74,7 +74,7 @@ const promptForFraimKey = async () => {
         process.exit(1);
     }
     console.log(chalk_1.default.blue('🔑 FRAIM Key Setup'));
-    console.log('FRAIM requires a valid API key to access workflows and features.\n');
+    console.log('FRAIM requires a valid API key to access jobs and features.\n');
     let key = null;
     let attempts = 0;
     const maxAttempts = 3;
@@ -149,7 +149,7 @@ const promptForMode = async () => {
             {
                 title: 'Conversational Mode',
                 value: 'conversational',
-                description: 'AI workflows only, no platform integration required'
+                description: 'AI jobs only, no platform integration required'
             }
         ],
         initial: 0
@@ -160,7 +160,7 @@ const promptForMode = async () => {
     }
     if (response.mode === 'conversational') {
         console.log(chalk_1.default.blue('\n✓ Conversational mode selected'));
-        console.log(chalk_1.default.gray('  You can use FRAIM workflows without platform credentials.'));
+        console.log(chalk_1.default.gray('  You can use FRAIM jobs without platform credentials.'));
         console.log(chalk_1.default.gray('  Platform features (issues, PRs) will be unavailable.\n'));
     }
     else if (response.mode === 'split') {
@@ -584,7 +584,7 @@ const runSetup = async (options) => {
         });
         if (mode === 'conversational' && Object.keys(mcpTokens).length === 0) {
             console.log(chalk_1.default.yellow('ℹ️  Conversational mode: Configuring MCP servers without platform integration'));
-            console.log(chalk_1.default.gray('   FRAIM workflows will work, but platform-specific features will be unavailable\n'));
+            console.log(chalk_1.default.gray('   FRAIM jobs will work, but platform-specific features will be unavailable\n'));
         }
         try {
             // Build providerConfigs map from configs
@@ -668,7 +668,7 @@ const runSetup = async (options) => {
     console.log(chalk_1.default.white('  layer of your AI-powered work at once: AI agents become an'));
     console.log(chalk_1.default.white('  accountable workforce, you become a capable AI manager, and'));
     console.log(chalk_1.default.white('  your leadership gains clear optics on AI proficiency.'));
-    console.log(chalk_1.default.gray('\n  60+ jobs across engineering, marketing, fundraising,'));
+    console.log(chalk_1.default.gray('\n  120+ jobs across engineering, marketing, fundraising,'));
     console.log(chalk_1.default.gray('  legal, product, hiring, customer development, and more.'));
     // Show which IDEs were configured and how to use FRAIM in each
     const { detectInstalledIDEs: detectIDEs } = await Promise.resolve().then(() => __importStar(require('../setup/ide-detector')));

package/dist/src/cli/fraim.js

@@ -50,6 +50,7 @@ const list_overridable_1 = require("./commands/list-overridable");
 const login_1 = require("./commands/login");
 const mcp_1 = require("./commands/mcp");
 const migrate_project_fraim_1 = require("./commands/migrate-project-fraim");
+const hub_1 = require("./commands/hub");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
@@ -89,6 +90,7 @@ program.addCommand(list_overridable_1.listOverridableCommand);
 program.addCommand(login_1.loginCommand);
 program.addCommand(mcp_1.mcpCommand);
 program.addCommand(migrate_project_fraim_1.migrateProjectFraimCommand);
+program.addCommand(hub_1.hubCommand);
 // Wait for async command initialization before parsing
 (async () => {
     // Import the initialization promise from setup command

package/dist/src/cli/mcp/command-resolution.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveManagedCommand = exports.getPortableNpxCommand = void 0;
+exports.resolveManagedCommand = exports.getSystemCommandPath = exports.getPortableNpxCommand = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
@@ -36,10 +36,43 @@ const getPortableNpxCommand = () => {
     return null;
 };
 exports.getPortableNpxCommand = getPortableNpxCommand;
+const getPathEntries = () => {
+    const rawPath = process.env.PATH || '';
+    return rawPath
+        .split(path_1.default.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+};
+const getSystemCommandCandidates = (command) => {
+    if (!command || path_1.default.isAbsolute(command)) {
+        return command ? [command] : [];
+    }
+    const commandNames = process.platform === 'win32'
+        ? command.includes('.')
+            ? [command]
+            : [command, `${command}.cmd`, `${command}.exe`, `${command}.bat`, `${command}.com`]
+        : [command];
+    return getPathEntries().flatMap((entry) => commandNames.map((name) => path_1.default.join(entry, name)));
+};
+const getSystemCommandPath = (command) => {
+    for (const candidate of getSystemCommandCandidates(command)) {
+        try {
+            const stats = fs_1.default.statSync(candidate);
+            if (stats.isFile()) {
+                return candidate;
+            }
+        }
+        catch {
+            // Ignore missing or inaccessible PATH entries and keep scanning.
+        }
+    }
+    return null;
+};
+exports.getSystemCommandPath = getSystemCommandPath;
 const resolveManagedCommand = (command) => {
     if (command !== 'npx') {
         return command;
     }
-    return (0, exports.getPortableNpxCommand)() || command;
+    return (0, exports.getPortableNpxCommand)() || (0, exports.getSystemCommandPath)(command) || command;
 };
 exports.resolveManagedCommand = resolveManagedCommand;

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

@@ -21,8 +21,9 @@ function describeConfiguredInvocationSurfaces(installedIDEs) {
     return installedIDEs.map((ide) => (0, ide_invocation_surfaces_1.describeInvocationSurface)(ide.name, ide.invocationProfile));
 }
 /**
- * Install the FRAIM slash command for Claude Code at the user level.
- * Writes to ~/.claude/commands/fraim.md and does not overwrite existing files.
+ * 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();
@@ -30,7 +31,8 @@ async function installSlashCommands(homeDir) {
     if (!fs_1.default.existsSync(claudeDir)) {
         return;
     }
-    installFileIfMissing(path_1.default.join(claudeDir, 'commands', 'fraim.md'), (0, ide_invocation_surfaces_1.buildClaudeSlashCommandContent)(), 'Claude slash command (~/.claude/commands/fraim.md)');
+    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.

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FRAIM_INVOCATION_BODY = exports.CURSOR_MDC_FRONTMATTER = exports.FRAIM_LAUNCH_PHRASE = void 0;
+exports.buildClaudeSkillContent = buildClaudeSkillContent;
+exports.buildClaudeCommandShimContent = buildClaudeCommandShimContent;
 exports.buildClaudeSlashCommandContent = buildClaudeSlashCommandContent;
 exports.buildCursorMentionRuleContent = buildCursorMentionRuleContent;
 exports.buildCodexSkillContent = buildCodexSkillContent;
@@ -12,7 +14,7 @@ exports.CURSOR_MDC_FRONTMATTER = `---
 description: FRAIM discovery and execution contract
 alwaysApply: true
 ---`;
-exports.FRAIM_INVOCATION_BODY = `Follow this process:
+exports.FRAIM_INVOCATION_BODY = `Follow this process:
 
 1. **If the user did not specify a FRAIM job or topic**:
    Call \`list_fraim_jobs()\` to discover available jobs. Present the results grouped by the categories returned by the server. For each group, list 3-5 of the most relevant jobs with a one-line description.
@@ -25,11 +27,23 @@ exports.FRAIM_INVOCATION_BODY = `Follow this process:
    - 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.
+   - 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.
 `;
+function buildClaudeSkillContent() {
+    return `# FRAIM
+
+${exports.FRAIM_INVOCATION_BODY}`;
+}
+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.
+
+${exports.FRAIM_INVOCATION_BODY}`;
+}
 function buildClaudeSlashCommandContent() {
-    return exports.FRAIM_INVOCATION_BODY;
+    return buildClaudeCommandShimContent();
 }
 function buildCursorMentionRuleContent() {
     return `${exports.CURSOR_MDC_FRONTMATTER}