faf-mcp 2.1.2 → 2.2.0

package/dist/src/handlers/tools.js

@@ -40,6 +40,7 @@ const os = __importStar(require("os"));
 const pathModule = __importStar(require("path"));
 const fuzzy_detector_1 = require("../utils/fuzzy-detector");
 const faf_file_finder_js_1 = require("../utils/faf-file-finder.js");
+const safe_path_1 = require("../utils/safe-path");
 const version_1 = require("../version");
 const path_resolver_1 = require("../utils/path-resolver");
 // v2.1.1: single-source scoring — same path the championship handler uses.
@@ -55,6 +56,7 @@ const path_resolver_1 = require("../utils/path-resolver");
 // once faf-cli drops the bad `bun` condition. See the bridge header for full
 // rationale and the linked tracked issue.
 const faf_cli_bridge_js_1 = require("../utils/faf-cli-bridge.js");
+const turbocat_bridge_js_1 = require("../faf-core/extract/turbocat-bridge.js");
 class FafToolHandler {
     engineAdapter;
     constructor(engineAdapter) {
@@ -66,12 +68,10 @@ class FafToolHandler {
      */
     getProjectPath(explicitPath) {
         if (explicitPath) {
-            // Expand tilde
-            const expandedPath = explicitPath.startsWith('~')
-                ? pathModule.join(os.homedir(), explicitPath.slice(1))
-                : explicitPath;
-            // Resolve to absolute path
-            const resolvedPath = pathModule.resolve(expandedPath);
+            // Confine the caller-supplied path. A passed *file* must be a .faf/.fafm
+            // context file; absolute/`..` escapes to secrets are refused. Throws
+            // PathConfinementError, caught centrally in callTool() (CWE-22/73/200).
+            const resolvedPath = (0, safe_path_1.confinePath)(explicitPath);
             // If it's a file path, get the directory
             const projectDir = fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isFile()
                 ? pathModule.dirname(resolvedPath)
@@ -281,7 +281,7 @@ class FafToolHandler {
                 },
                 {
                     name: 'faf_read',
-                    description: 'Read content from any file on the local filesystem',
+                    description: 'Read a file within the project root (cwd / FAF_ALLOWED_ROOTS). Paths that escape the project are refused.',
                     annotations: {
                         title: 'Read .faf File',
                         readOnlyHint: true,
@@ -301,7 +301,7 @@ class FafToolHandler {
                 },
                 {
                     name: 'faf_write',
-                    description: 'Write content to any file on the local filesystem',
+                    description: 'Write a file within the project root (cwd / FAF_ALLOWED_ROOTS). Paths that escape the project are refused.',
                     annotations: {
                         title: 'Write .faf File',
                         readOnlyHint: false,
@@ -358,20 +358,9 @@ class FafToolHandler {
                         additionalProperties: false
                     }
                 },
-                {
-                    name: 'faf_chat',
-                    description: '🗣️ Natural language project.faf generation - Ask 6W questions (Who/What/Why/Where/When/How) to build complete human context 🧡⚡️',
-                    annotations: {
-                        title: 'Chat about FAF',
-                        readOnlyHint: true,
-                        openWorldHint: false
-                    },
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                        additionalProperties: false
-                    }
-                },
+                // faf_chat — DEPRECATED, un-advertised. The host IS the chat — a chat-shim
+                // tool is redundant. Dispatch keeps a deprecation stub (below). Fleet sweep —
+                // mirrors grok-faf-mcp + claude-faf-mcp's retire.
                 {
                     name: 'faf_friday',
                     description: '🎉 Friday Features - Chrome Extension detection, fuzzy matching & more! 🧡⚡️',
@@ -705,81 +694,91 @@ class FafToolHandler {
         if (!name || typeof name !== 'string') {
             throw new Error('Tool name must be a non-empty string');
         }
-        switch (name) {
-            case 'faf_status':
-                return await this.handleFafStatus(args);
-            case 'faf_score':
-                return await this.handleFafScore(args);
-            case 'faf_init':
-                return await this.handleFafInit(args);
-            case 'faf_trust':
-                return await this.handleFafTrust(args);
-            case 'faf_sync':
-                return await this.handleFafSync(args);
-            case 'faf_enhance':
-                return await this.handleFafEnhance(args);
-            case 'faf_bi_sync':
-                return await this.handleFafBiSync(args);
-            case 'faf_clear':
-                return await this.handleFafClear(args);
-            case 'faf_debug':
-                return await this.handleFafDebug(args);
-            case 'faf_about':
-                return await this.handleFafAbout(args);
-            case 'faf_what':
-                return await this.handleFafWhat(args);
-            case 'faf_read': {
-                // Handle faf_read specially to set context when reading project.faf files
-                const readResult = await fileHandler_1.fileHandlers.faf_read(args);
-                // If reading a project.faf file, set the session context
-                if (args?.path && (args.path.includes('project.faf') || args.path.endsWith('.faf'))) {
-                    this.getProjectPath(args.path);
+        try {
+            switch (name) {
+                case 'faf_status':
+                    return await this.handleFafStatus(args);
+                case 'faf_score':
+                    return await this.handleFafScore(args);
+                case 'faf_init':
+                    return await this.handleFafInit(args);
+                case 'faf_trust':
+                    return await this.handleFafTrust(args);
+                case 'faf_sync':
+                    return await this.handleFafSync(args);
+                case 'faf_enhance':
+                    return await this.handleFafEnhance(args);
+                case 'faf_bi_sync':
+                    return await this.handleFafBiSync(args);
+                case 'faf_clear':
+                    return await this.handleFafClear(args);
+                case 'faf_debug':
+                    return await this.handleFafDebug(args);
+                case 'faf_about':
+                    return await this.handleFafAbout(args);
+                case 'faf_what':
+                    return await this.handleFafWhat(args);
+                case 'faf_read': {
+                    // Handle faf_read specially to set context when reading project.faf files
+                    const readResult = await fileHandler_1.fileHandlers.faf_read(args);
+                    // If reading a project.faf file, set the session context
+                    if (args?.path && (args.path.includes('project.faf') || args.path.endsWith('.faf'))) {
+                        this.getProjectPath(args.path);
+                    }
+                    return readResult;
                 }
-                return readResult;
-            }
-            case 'faf_chat':
-                return await this.handleFafChat(args);
-            case 'faf_friday':
-                return await this.handleFafFriday(args);
-            case 'faf_write':
-                return await fileHandler_1.fileHandlers.faf_write(args);
-            case 'faf_list':
-                return await this.handleFafList(args);
-            case 'faf_guide':
-                return await this.handleFafGuide(args);
-            case 'faf_readme':
-                return await this.handleFafReadme(args);
-            case 'faf_human_add':
-                return await this.handleFafHumanAdd(args);
-            case 'faf_check':
-                return await this.handleFafCheck(args);
-            case 'faf_context':
-                return await this.handleFafContext(args);
-            case 'faf_go':
-                return await this.handleFafGo(args);
-            case 'faf_auto':
-                return await this.handleFafAuto(args);
-            case 'faf_dna':
-                return await this.handleFafDna(args);
-            case 'faf_formats':
-                return await this.handleFafFormats(args);
-            case 'faf_quick':
-                return await this.handleFafQuick(args);
-            case 'faf_doctor':
-                return await this.handleFafDoctor(args);
-            // v4.5.0 Interop tools
-            case 'faf_agents':
-                return await this.handleFafAgents(args);
-            case 'faf_cursor':
-                return await this.handleFafCursor(args);
-            case 'faf_gemini':
-                return await this.handleFafGemini(args);
-            case 'faf_conductor':
-                return await this.handleFafConductor(args);
-            case 'faf_git':
-                return await this.handleFafGit(args);
-            default:
-                throw new Error(`Unknown tool: ${name}`);
+                case 'faf_chat':
+                    return await this.handleFafChat(args);
+                case 'faf_friday':
+                    return await this.handleFafFriday(args);
+                case 'faf_write':
+                    return await fileHandler_1.fileHandlers.faf_write(args);
+                case 'faf_list':
+                    return await this.handleFafList(args);
+                case 'faf_guide':
+                    return await this.handleFafGuide(args);
+                case 'faf_readme':
+                    return await this.handleFafReadme(args);
+                case 'faf_human_add':
+                    return await this.handleFafHumanAdd(args);
+                case 'faf_check':
+                    return await this.handleFafCheck(args);
+                case 'faf_context':
+                    return await this.handleFafContext(args);
+                case 'faf_go':
+                    return await this.handleFafGo(args);
+                case 'faf_auto':
+                    return await this.handleFafAuto(args);
+                case 'faf_dna':
+                    return await this.handleFafDna(args);
+                case 'faf_formats':
+                    return await this.handleFafFormats(args);
+                case 'faf_quick':
+                    return await this.handleFafQuick(args);
+                case 'faf_doctor':
+                    return await this.handleFafDoctor(args);
+                // v4.5.0 Interop tools
+                case 'faf_agents':
+                    return await this.handleFafAgents(args);
+                case 'faf_cursor':
+                    return await this.handleFafCursor(args);
+                case 'faf_gemini':
+                    return await this.handleFafGemini(args);
+                case 'faf_conductor':
+                    return await this.handleFafConductor(args);
+                case 'faf_git':
+                    return await this.handleFafGit(args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        }
+        catch (err) {
+            // Central catch for path-confinement violations from getProjectPath()
+            // (CWE-22/73/200). Anything else propagates unchanged.
+            if (err instanceof safe_path_1.PathConfinementError) {
+                return { content: [{ type: 'text', text: `PATH DENIED\n\n${err.message}` }], isError: true };
+            }
+            throw err;
         }
     }
     async handleFafStatus(args) {
@@ -1307,37 +1306,17 @@ ${debugInfo.permissions.fafError ? `   FAF Error: ${debugInfo.permissions.fafErr
         }
     }
     async handleFafChat(_args) {
-        try {
-            const result = await this.engineAdapter.callEngine('chat');
-            if (!result.success) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `Error running faf chat: ${result.error || 'Unknown error'}`
-                        }],
-                    isError: true
-                };
-            }
-            // Format the response text
-            const responseText = typeof result.data === 'string'
-                ? result.data
-                : result.data?.output || JSON.stringify(result.data, null, 2);
-            return {
-                content: [{
-                        type: 'text',
-                        text: responseText
-                    }]
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error running faf chat: ${error instanceof Error ? error.message : String(error)}`
-                    }],
-                isError: true
-            };
-        }
+        // DEPRECATED: the host IS the chat — a chat-shim MCP tool is redundant.
+        // Un-advertised in listTools; this stub stays so anyone still wired gets a
+        // clear signal, not a crash. The old body shelled `faf chat` via the engine
+        // subprocess (a command faf-cli no longer ships) — removing it ends that dead shell.
+        return {
+            content: [{
+                    type: 'text',
+                    text: 'faf_chat is retired — the host is your chat, just talk here. ' +
+                        'For FAF: faf_init / faf_score / faf_sync, or "ask questions" to build context.',
+                }],
+        };
     }
     async handleFafFriday(args) {
         const { test } = args || {};
@@ -1888,127 +1867,14 @@ All work: \`faf init\`, \`faf init new\`, \`faf init --new\`, \`faf init -new\`
             }
             const fafContent = fs.readFileSync(fafResult.path, 'utf-8');
             const fafData = yaml.parse(fafContent) || {};
-            // Question registry - maps field paths to questions
-            const QUESTION_REGISTRY = {
-                'project.goal': {
-                    question: 'What does this project do? (one sentence)',
-                    header: 'Goal',
-                    type: 'text',
-                    required: true
-                },
-                'project.name': {
-                    question: 'What is the name of this project?',
-                    header: 'Name',
-                    type: 'text',
-                    required: true
-                },
-                'project.main_language': {
-                    question: 'What is the primary programming language?',
-                    header: 'Language',
-                    type: 'select',
-                    required: true,
-                    options: [
-                        { label: 'TypeScript', value: 'TypeScript', description: 'JavaScript with types' },
-                        { label: 'JavaScript', value: 'JavaScript', description: 'Vanilla JS or Node.js' },
-                        { label: 'Python', value: 'Python', description: 'Python 3.x' },
-                        { label: 'Rust', value: 'Rust', description: 'Systems programming' },
-                        { label: 'Go', value: 'Go', description: 'Golang' },
-                        { label: 'Other', value: 'Other', description: 'Specify manually' }
-                    ]
-                },
-                'human_context.why': {
-                    question: 'Why does this project exist? (motivation)',
-                    header: 'Why',
-                    type: 'text',
-                    required: true
-                },
-                'human_context.who': {
-                    question: 'Who uses this project? (target audience)',
-                    header: 'Who',
-                    type: 'text',
-                    required: false
-                },
-                'human_context.what': {
-                    question: 'What problem does this solve?',
-                    header: 'What',
-                    type: 'text',
-                    required: false
-                },
-                'human_context.where': {
-                    question: 'Where does this run? (environment)',
-                    header: 'Where',
-                    type: 'text',
-                    required: false
-                },
-                'human_context.when': {
-                    question: 'When was this started or what phase is it in?',
-                    header: 'When',
-                    type: 'text',
-                    required: false
-                },
-                'human_context.how': {
-                    question: 'How should AI assist with this project?',
-                    header: 'How',
-                    type: 'text',
-                    required: false
-                },
-                'stack.frontend': {
-                    question: 'What frontend framework do you use?',
-                    header: 'Frontend',
-                    type: 'select',
-                    required: false,
-                    options: [
-                        { label: 'React', value: 'React', description: 'React.js' },
-                        { label: 'Vue', value: 'Vue', description: 'Vue.js' },
-                        { label: 'Svelte', value: 'Svelte', description: 'Svelte/SvelteKit' },
-                        { label: 'Next.js', value: 'Next.js', description: 'React framework' },
-                        { label: 'None', value: 'None', description: 'No frontend' },
-                        { label: 'Other', value: 'Other', description: 'Specify manually' }
-                    ]
-                },
-                'stack.backend': {
-                    question: 'What backend framework do you use?',
-                    header: 'Backend',
-                    type: 'select',
-                    required: false,
-                    options: [
-                        { label: 'Express', value: 'Express', description: 'Node.js Express' },
-                        { label: 'Fastify', value: 'Fastify', description: 'Node.js Fastify' },
-                        { label: 'Django', value: 'Django', description: 'Python Django' },
-                        { label: 'FastAPI', value: 'FastAPI', description: 'Python FastAPI' },
-                        { label: 'None', value: 'None', description: 'No backend' },
-                        { label: 'Other', value: 'Other', description: 'Specify manually' }
-                    ]
-                },
-                'stack.database': {
-                    question: 'What database do you use?',
-                    header: 'Database',
-                    type: 'select',
-                    required: false,
-                    options: [
-                        { label: 'PostgreSQL', value: 'PostgreSQL', description: 'Relational database' },
-                        { label: 'MongoDB', value: 'MongoDB', description: 'Document database' },
-                        { label: 'SQLite', value: 'SQLite', description: 'File-based database' },
-                        { label: 'Supabase', value: 'Supabase', description: 'Postgres + auth' },
-                        { label: 'None', value: 'None', description: 'No database' },
-                        { label: 'Other', value: 'Other', description: 'Specify manually' }
-                    ]
-                },
-                'stack.hosting': {
-                    question: 'Where is this hosted/deployed?',
-                    header: 'Hosting',
-                    type: 'select',
-                    required: false,
-                    options: [
-                        { label: 'Vercel', value: 'Vercel', description: 'Frontend/serverless' },
-                        { label: 'AWS', value: 'AWS', description: 'Amazon Web Services' },
-                        { label: 'Cloudflare', value: 'Cloudflare', description: 'Workers/Pages' },
-                        { label: 'Railway', value: 'Railway', description: 'App hosting' },
-                        { label: 'Local only', value: 'Local', description: 'Not deployed' },
-                        { label: 'Other', value: 'Other', description: 'Specify manually' }
-                    ]
-                }
-            };
+            // Single-source the HUMAN interview from faf-cli's canonical SIX_WS_INTERVIEW
+            // (8 = the 6Ws + name + goal; public since 6.9.0). This is THE 6Ws — human-
+            // only context that can't be derived. main_language + stack are NOT here:
+            // they're SOURCED by Turbo-Cat (faf-cli's separate STACK_INTERVIEW if ever
+            // needed), never asked of a human. (Decision: single-source the 8-Q 6Ws
+            // Interview, wolfejam 2026-06-10 — language is not on the human side.)
+            const { SIX_WS_INTERVIEW } = await faf_cli_bridge_js_1.fafCli;
+            const QUESTION_REGISTRY = Object.fromEntries(SIX_WS_INTERVIEW.map((q) => [q.path, q]));
             // Priority order for questions
             const priorityOrder = [
                 'project.goal',
@@ -2088,14 +1954,11 @@ All work: \`faf init\`, \`faf init new\`, \`faf init --new\`, \`faf init -new\`
                         }]
                 };
             }
-            // PHASE 1: Analyze and return questions
-            const missingFields = [];
-            for (const fieldPath of Object.keys(QUESTION_REGISTRY)) {
-                const value = getNestedValue(fafData, fieldPath);
-                if (isEmpty(value)) {
-                    missingFields.push(fieldPath);
-                }
-            }
+            // PHASE 1: Analyze and return questions — the canonical 6Ws (SIX_WS_INTERVIEW),
+            // scoped to slots that are empty AND active (slotignored is never asked).
+            const missingFields = SIX_WS_INTERVIEW
+                .filter((q) => { const v = getNestedValue(fafData, q.path); return v !== 'slotignored' && isEmpty(v); })
+                .map((q) => q.path);
             // Calculate current score
             const totalFields = Object.keys(QUESTION_REGISTRY).length;
             const filledFields = totalFields - missingFields.length;
@@ -2216,13 +2079,16 @@ faffless: true
             const fafContent = fs.readFileSync(fafPath, 'utf-8');
             const fafData = yaml.parse(fafContent) || {};
             currentScore = this.calculateSimpleScore(fafData);
-            // Step 2: Run TURBO-CAT format discovery
-            const formatsResult = await this.discoverFormatsInternal(cwd);
-            if (formatsResult.discoveredFormats.length > 0) {
-                // Apply slot fills to .faf
+            // Step 2: Run TURBO-CAT format discovery — composed from faf-cli's engine.
+            const formatsResult = await (0, turbocat_bridge_js_1.composedTurboCat)(cwd);
+            if (formatsResult && formatsResult.discoveredFormats.length > 0) {
+                // Apply slot fills to .faf. turboCatSlots routes them into the correct
+                // .faf sections; fill the stack section (main_language lives under
+                // project, which is a string here) — clean keys, no noise.
+                const slots = await (0, turbocat_bridge_js_1.composedTurboCatSlots)(cwd);
                 if (!fafData.stack)
                     fafData.stack = {};
-                for (const [key, value] of Object.entries(formatsResult.slotFillRecommendations)) {
+                for (const [key, value] of Object.entries(slots?.stack ?? {})) {
                     if (!fafData.stack[key] || fafData.stack[key] === 'None') {
                         fafData.stack[key] = value;
                     }
@@ -2458,7 +2324,7 @@ ${fafData.stack_signature || 'Auto-detected stack'}
         const cwd = this.getProjectPath(args?.path);
         const startTime = Date.now();
         try {
-            const analysis = await this.discoverFormatsInternal(cwd);
+            const analysis = await (0, turbocat_bridge_js_1.turboCatDisplay)(cwd);
             const elapsed = Date.now() - startTime;
             if (args?.json) {
                 return {
@@ -2497,116 +2363,6 @@ ${fafData.stack_signature || 'Auto-detected stack'}
             };
         }
     }
-    /**
-     * Internal helper: Discover formats in a directory (TURBO-CAT logic)
-     */
-    async discoverFormatsInternal(projectDir) {
-        const path = await import('path');
-        // Known format files and their categories
-        const KNOWN_FORMATS = {
-            'package.json': { category: 'package-manager', priority: 35 },
-            'tsconfig.json': { category: 'typescript-config', priority: 30 },
-            'Cargo.toml': { category: 'package-manager', priority: 35 },
-            'pyproject.toml': { category: 'package-manager', priority: 35 },
-            'requirements.txt': { category: 'package-manager', priority: 25 },
-            'go.mod': { category: 'package-manager', priority: 35 },
-            'pom.xml': { category: 'package-manager', priority: 35 },
-            'README.md': { category: 'documentation', priority: 20 },
-            'CLAUDE.md': { category: 'ai-context', priority: 40 },
-            'project.faf': { category: 'faf-context', priority: 45 },
-            '.faf': { category: 'faf-context', priority: 45 },
-            'Dockerfile': { category: 'docker', priority: 25 },
-            'docker-compose.yml': { category: 'docker', priority: 25 },
-            'vercel.json': { category: 'deployment', priority: 20 },
-            'netlify.toml': { category: 'deployment', priority: 20 },
-            '.eslintrc.json': { category: 'linting', priority: 15 },
-            '.prettierrc': { category: 'linting', priority: 15 },
-            'jest.config.js': { category: 'testing', priority: 20 },
-            'vitest.config.ts': { category: 'testing', priority: 20 },
-            'svelte.config.js': { category: 'framework', priority: 30 },
-            'next.config.js': { category: 'framework', priority: 30 },
-            'vite.config.ts': { category: 'build', priority: 25 },
-            'webpack.config.js': { category: 'build', priority: 25 },
-            '.github': { category: 'ci-cd', priority: 20 },
-            'manifest.json': { category: 'chrome-extension', priority: 35 }
-        };
-        const discoveredFormats = [];
-        let totalIntelligenceScore = 0;
-        const slotFillRecommendations = {};
-        const extractedContext = {};
-        // Scan directory
-        try {
-            const files = fs.readdirSync(projectDir);
-            for (const file of files) {
-                if (KNOWN_FORMATS[file]) {
-                    const format = KNOWN_FORMATS[file];
-                    discoveredFormats.push({
-                        fileName: file,
-                        category: format.category,
-                        priority: format.priority
-                    });
-                    totalIntelligenceScore += format.priority;
-                }
-            }
-            // Extract intelligence from package.json
-            const pkgPath = path.join(projectDir, 'package.json');
-            if (fs.existsSync(pkgPath)) {
-                const pkgContent = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-                const allDeps = { ...pkgContent.dependencies, ...pkgContent.devDependencies };
-                extractedContext.projectName = pkgContent.name;
-                extractedContext.projectDescription = pkgContent.description;
-                // Detect frameworks and fill slots
-                if (allDeps['typescript'] || allDeps['@types/node']) {
-                    slotFillRecommendations['mainLanguage'] = 'TypeScript';
-                }
-                if (allDeps['react'] || allDeps['next']) {
-                    slotFillRecommendations['frontend'] = allDeps['next'] ? 'Next.js' : 'React';
-                }
-                if (allDeps['vue'] || allDeps['nuxt']) {
-                    slotFillRecommendations['frontend'] = allDeps['nuxt'] ? 'Nuxt' : 'Vue';
-                }
-                if (allDeps['svelte'] || allDeps['@sveltejs/kit']) {
-                    slotFillRecommendations['frontend'] = allDeps['@sveltejs/kit'] ? 'SvelteKit' : 'Svelte';
-                }
-                if (allDeps['express']) {
-                    slotFillRecommendations['backend'] = 'Express';
-                }
-                if (allDeps['fastify']) {
-                    slotFillRecommendations['backend'] = 'Fastify';
-                }
-                if (allDeps['vite']) {
-                    slotFillRecommendations['build'] = 'Vite';
-                }
-                if (allDeps['jest'] || allDeps['vitest']) {
-                    slotFillRecommendations['testing'] = allDeps['vitest'] ? 'Vitest' : 'Jest';
-                }
-            }
-            // Check for deployment indicators
-            if (fs.existsSync(path.join(projectDir, 'vercel.json'))) {
-                slotFillRecommendations['hosting'] = 'Vercel';
-            }
-            else if (fs.existsSync(path.join(projectDir, 'netlify.toml'))) {
-                slotFillRecommendations['hosting'] = 'Netlify';
-            }
-        }
-        catch (error) {
-            // Ignore errors, return empty results
-        }
-        // Generate stack signature
-        const parts = [];
-        if (slotFillRecommendations['mainLanguage'])
-            parts.push(slotFillRecommendations['mainLanguage'].toLowerCase());
-        if (slotFillRecommendations['frontend'])
-            parts.push(slotFillRecommendations['frontend'].toLowerCase());
-        const stackSignature = parts.length > 0 ? parts.join('-') : 'unknown-stack';
-        return {
-            discoveredFormats,
-            totalIntelligenceScore,
-            stackSignature,
-            slotFillRecommendations,
-            extractedContext
-        };
-    }
     /**
      * Internal helper: Calculate simple score from .faf data
      */