fraim-framework 2.0.154 → 2.0.159

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

@@ -56,10 +56,10 @@ function buildFraimInvocationBody(profile = 'none') {
     return `Follow this process:
 
 ${buildDeferredToolBootstrapSection(profile)}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.
+   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 \`list_fraim_jobs()\`. 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.
+   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>" })\`.

package/dist/src/cli/utils/github-workflow-sync.js

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GITHUB_WORKFLOW_ASSET_PREFIX = exports.GITHUB_WORKFLOW_HEADER = exports.GITHUB_WORKFLOW_MANIFEST_RELATIVE_PATH = void 0;
+exports.isGitHubWorkflowAutomationEnabled = isGitHubWorkflowAutomationEnabled;
+exports.decorateManagedGitHubWorkflow = decorateManagedGitHubWorkflow;
+exports.isFraimManagedGitHubWorkflow = isFraimManagedGitHubWorkflow;
+exports.loadGitHubWorkflowManifest = loadGitHubWorkflowManifest;
+exports.loadLocalGitHubWorkflowBundle = loadLocalGitHubWorkflowBundle;
+exports.fetchGitHubWorkflowBundle = fetchGitHubWorkflowBundle;
+exports.reconcileGitHubWorkflowAssets = reconcileGitHubWorkflowAssets;
+exports.formatGitHubWorkflowSyncSummary = formatGitHubWorkflowSyncSummary;
+const axios_1 = __importDefault(require("axios"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_loader_1 = require("../../core/config-loader");
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+exports.GITHUB_WORKFLOW_MANIFEST_RELATIVE_PATH = path_1.default.join('fraim', 'managed-assets', 'github-workflows.json');
+exports.GITHUB_WORKFLOW_HEADER = '# FRAIM-MANAGED: github-workflow';
+exports.GITHUB_WORKFLOW_ASSET_PREFIX = '# FRAIM-ASSET-ID: ';
+function sha256(content) {
+    return `sha256:${crypto_1.default.createHash('sha256').update(content).digest('hex')}`;
+}
+function getManifestPath(projectRoot) {
+    return path_1.default.join(projectRoot, exports.GITHUB_WORKFLOW_MANIFEST_RELATIVE_PATH);
+}
+function isGitHubWorkflowAutomationEnabled(config) {
+    return config?.customizations?.githubWorkflows?.enabled === true;
+}
+function decorateManagedGitHubWorkflow(assetId, content) {
+    const normalized = content.replace(/^\uFEFF/, '');
+    const assetHeader = `${exports.GITHUB_WORKFLOW_HEADER}\n${exports.GITHUB_WORKFLOW_ASSET_PREFIX}${assetId}`;
+    if (normalized.includes(exports.GITHUB_WORKFLOW_HEADER) && normalized.includes(`${exports.GITHUB_WORKFLOW_ASSET_PREFIX}${assetId}`)) {
+        return normalized;
+    }
+    return `${assetHeader}\n${normalized}`;
+}
+function isFraimManagedGitHubWorkflow(content, assetId) {
+    if (!content.includes(exports.GITHUB_WORKFLOW_HEADER)) {
+        return false;
+    }
+    if (!assetId) {
+        return true;
+    }
+    return content.includes(`${exports.GITHUB_WORKFLOW_ASSET_PREFIX}${assetId}`);
+}
+function loadGitHubWorkflowManifest(projectRoot) {
+    const manifestPath = getManifestPath(projectRoot);
+    if (!fs_1.default.existsSync(manifestPath)) {
+        return {
+            version: 1,
+            enabled: true,
+            provider: 'github',
+            managedFiles: []
+        };
+    }
+    return JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+}
+function writeGitHubWorkflowManifest(projectRoot, manifest) {
+    const manifestPath = getManifestPath(projectRoot);
+    fs_1.default.mkdirSync(path_1.default.dirname(manifestPath), { recursive: true });
+    fs_1.default.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+}
+function loadLocalGitHubWorkflowBundle(registryRoot) {
+    const workflowsRoot = path_1.default.join(registryRoot, 'github', 'workflows');
+    if (!fs_1.default.existsSync(workflowsRoot)) {
+        return [];
+    }
+    const files = fs_1.default.readdirSync(workflowsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.yml'))
+        .map((entry) => {
+        const fullPath = path_1.default.join(workflowsRoot, entry.name);
+        const content = fs_1.default.readFileSync(fullPath, 'utf8');
+        return {
+            path: entry.name,
+            content,
+            type: 'github-workflow',
+            digest: sha256(content)
+        };
+    });
+    return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function fetchGitHubWorkflowBundle(options) {
+    const response = await axios_1.default.get(`${options.remoteUrl}/api/registry/github-workflows`, {
+        headers: {
+            'x-api-key': options.apiKey
+        },
+        timeout: 30000
+    });
+    return (response.data.files || []);
+}
+function readProjectConfig(projectRoot, config) {
+    if (config) {
+        return config;
+    }
+    return (0, config_loader_1.loadFraimConfig)((0, project_fraim_paths_1.getWorkspaceConfigPath)(projectRoot));
+}
+function reconcileGitHubWorkflowAssets(options) {
+    const config = readProjectConfig(options.projectRoot, options.config);
+    const provider = config.repository?.provider || null;
+    if (provider !== 'github') {
+        return {
+            enabled: false,
+            provider,
+            skippedReason: 'non-GitHub repo',
+            results: []
+        };
+    }
+    if (!isGitHubWorkflowAutomationEnabled(config)) {
+        return {
+            enabled: false,
+            provider,
+            skippedReason: 'GitHub workflow automation disabled',
+            results: []
+        };
+    }
+    const manifest = loadGitHubWorkflowManifest(options.projectRoot);
+    const manifestEntries = new Map(manifest.managedFiles.map((entry) => [entry.path, entry]));
+    const workflowsDir = path_1.default.join(options.projectRoot, '.github', 'workflows');
+    fs_1.default.mkdirSync(workflowsDir, { recursive: true });
+    const results = [];
+    const nextManagedFiles = [];
+    for (const file of options.files) {
+        const assetId = path_1.default.basename(file.path);
+        const relativeWorkflowPath = path_1.default.join('.github', 'workflows', file.path).replace(/[\\/]/g, '/');
+        const destinationPath = path_1.default.join(options.projectRoot, '.github', 'workflows', file.path);
+        const desiredContent = decorateManagedGitHubWorkflow(assetId, file.content);
+        const desiredInstalledDigest = sha256(desiredContent);
+        const previousEntry = manifestEntries.get(relativeWorkflowPath);
+        if (!fs_1.default.existsSync(destinationPath)) {
+            fs_1.default.mkdirSync(path_1.default.dirname(destinationPath), { recursive: true });
+            fs_1.default.writeFileSync(destinationPath, desiredContent, 'utf8');
+            nextManagedFiles.push({
+                path: relativeWorkflowPath,
+                assetId,
+                sourceDigest: file.digest,
+                installedDigest: desiredInstalledDigest
+            });
+            results.push({
+                path: relativeWorkflowPath,
+                assetId,
+                status: 'installed'
+            });
+            continue;
+        }
+        const currentContent = fs_1.default.readFileSync(destinationPath, 'utf8');
+        const currentDigest = sha256(currentContent);
+        const ownedByFraim = isFraimManagedGitHubWorkflow(currentContent, assetId) || Boolean(previousEntry);
+        if (!ownedByFraim) {
+            if (previousEntry) {
+                nextManagedFiles.push(previousEntry);
+            }
+            results.push({
+                path: relativeWorkflowPath,
+                assetId,
+                status: 'conflict',
+                reason: 'same-named file exists without FRAIM ownership marker'
+            });
+            continue;
+        }
+        if (currentDigest === desiredInstalledDigest) {
+            nextManagedFiles.push({
+                path: relativeWorkflowPath,
+                assetId,
+                sourceDigest: file.digest,
+                installedDigest: desiredInstalledDigest
+            });
+            results.push({
+                path: relativeWorkflowPath,
+                assetId,
+                status: 'already current'
+            });
+            continue;
+        }
+        if (previousEntry && currentDigest === previousEntry.installedDigest) {
+            fs_1.default.writeFileSync(destinationPath, desiredContent, 'utf8');
+            nextManagedFiles.push({
+                path: relativeWorkflowPath,
+                assetId,
+                sourceDigest: file.digest,
+                installedDigest: desiredInstalledDigest
+            });
+            results.push({
+                path: relativeWorkflowPath,
+                assetId,
+                status: 'updated'
+            });
+            continue;
+        }
+        nextManagedFiles.push(previousEntry || {
+            path: relativeWorkflowPath,
+            assetId,
+            sourceDigest: file.digest,
+            installedDigest: currentDigest
+        });
+        results.push({
+            path: relativeWorkflowPath,
+            assetId,
+            status: 'conflict',
+            reason: previousEntry
+                ? 'managed file has local edits that do not match the last installed digest'
+                : 'FRAIM-managed header exists without manifest baseline'
+        });
+    }
+    writeGitHubWorkflowManifest(options.projectRoot, {
+        version: 1,
+        enabled: true,
+        provider: 'github',
+        managedFiles: nextManagedFiles.sort((a, b) => a.path.localeCompare(b.path))
+    });
+    return {
+        enabled: true,
+        provider,
+        results
+    };
+}
+function formatGitHubWorkflowSyncSummary(result) {
+    if (!result.enabled) {
+        return [`GitHub workflow reconciliation skipped: ${result.skippedReason || 'not enabled'}`];
+    }
+    if (result.results.length === 0) {
+        return ['GitHub workflow reconciliation: no workflow assets found'];
+    }
+    return result.results.map((item) => {
+        const suffix = item.reason ? ` (${item.reason})` : '';
+        return `GitHub workflow ${item.status}: ${item.path}${suffix}`;
+    });
+}

package/dist/src/cli/utils/managed-agent-paths.js

@@ -34,7 +34,7 @@ function getManagedAgentBinDirs() {
     const portableNodeBin = getPortableNodeBinPath();
     const candidates = process.platform === 'win32'
         ? [nodeRoot, portableNodeBin]
-        : [path_1.default.join(nodeRoot, 'bin'), portableNodeBin];
+        : [nodeRoot, path_1.default.join(nodeRoot, 'bin'), portableNodeBin];
     return [...new Set(candidates.filter(Boolean))];
 }
 function buildPathWithManagedAgentBins(basePath) {

package/dist/src/cli/utils/project-bootstrap.js

@@ -22,7 +22,7 @@ function formatModeLabel(mode) {
 function getModeSpecificNextStep(mode) {
     switch (mode) {
         case 'conversational':
-            return `The agent will create fraim/config.json during onboarding, then focus on project context, validation commands, and durable repo rules. For a walkthrough, watch the onboarding videos at ${ONBOARDING_VIDEO_PLAYLIST_URL}.`;
+            return `The agent will create fraim/config.json during onboarding, then focus on project context, validation commands, and durable project rules. For a walkthrough, watch the onboarding videos at ${ONBOARDING_VIDEO_PLAYLIST_URL}.`;
         case 'split':
             return `The agent will create fraim/config.json during onboarding, confirm the code-host and issue-tracker split, then ask only for the missing project details. For a walkthrough, watch the onboarding videos at ${ONBOARDING_VIDEO_PLAYLIST_URL}.`;
         default:
@@ -70,12 +70,15 @@ function buildInitProjectSummary(result) {
 }
 function printInitProjectSummary(result) {
     const summary = buildInitProjectSummary(result);
+    const showRepositoryDetails = result.mode !== 'conversational';
     console.log(chalk_1.default.green(`\n${summary.status}`));
     console.log(chalk_1.default.blue('Project summary:'));
     console.log(chalk_1.default.gray(`   Mode: ${summary.fields.mode}`));
     console.log(chalk_1.default.gray(`   Project: ${summary.fields.project}`));
-    console.log(chalk_1.default.gray(`   Repository detection: ${summary.fields.repositoryDetection}`));
-    console.log(chalk_1.default.gray(`   Issue tracking: ${summary.fields.issueTracking}`));
+    if (showRepositoryDetails) {
+        console.log(chalk_1.default.gray(`   Repository detection: ${summary.fields.repositoryDetection}`));
+        console.log(chalk_1.default.gray(`   Issue tracking: ${summary.fields.issueTracking}`));
+    }
     console.log(chalk_1.default.gray(`   Sync: ${summary.fields.sync}`));
     if (summary.fields.createdPaths.length > 0) {
         console.log(chalk_1.default.gray(`   Created: ${summary.fields.createdPaths.join(', ')}`));

package/dist/src/core/ai-mentor.js

@@ -28,7 +28,6 @@ class AIMentor {
                 throw new Error(`Phase "${args.currentPhase}" not found in job "${args.jobName}".`);
             }
         }
-        // Handle different statuses
         if (args.status === 'starting') {
             return await this.generateStartingMessage(workflow, args.currentPhase, args.skipIncludes);
         }
@@ -63,27 +62,17 @@ class AIMentor {
     buildReportBackFooter(jobName, phaseId, phaseFlow) {
         if (!phaseFlow)
             return '';
-        const base = `seekMentoring({
-  jobName: "${jobName}",
-  issueNumber: "<issue_number>",
-  currentPhase: "${phaseId}",
-  status: "complete",`;
         const onSuccess = phaseFlow.onSuccess;
-        let successBlock;
-        if (!onSuccess) {
-            successBlock = `\n\n---\n\n> **⚑ Phase Complete — Report Back**\n> When you have finished all steps above, call:\n> \`\`\`javascript\n> ${base}\n>   // This is the final phase.\n> })\n> \`\`\``;
-        }
-        else if (typeof onSuccess === 'string') {
-            successBlock = `\n\n---\n\n> **⚑ Phase Complete — Report Back**\n> When you have finished all steps above, call:\n> \`\`\`javascript\n> ${base}\n> })\n> \`\`\``;
-        }
-        else {
-            const validOutcomes = Object.keys(onSuccess)
-                .filter(k => k !== 'default')
-                .map(k => `"${k}"`)
-                .join(' | ');
-            successBlock = `\n\n---\n\n> **⚑ Phase Complete — Report Back**\n> The next phase depends on your outcome. Set \`findings.issueType\` (or \`findings.phaseOutcome\`) to one of: ${validOutcomes}\n>\n> Then call:\n> \`\`\`javascript\n> ${base}\n>   findings: { issueType: "<Outcome>" }\n> })\n> \`\`\``;
-        }
-        return successBlock;
+        const completionCall = `seekMentoring({ jobName: "${jobName}", issueNumber: "<issue_number>", currentPhase: "${phaseId}", status: "complete" })`;
+        if (!onSuccess || typeof onSuccess === 'string') {
+            const finalPhaseNote = onSuccess ? '' : ' This is the final phase.';
+            return `\n\n---\n\n## Report Back\nWhen this phase is done, call \`${completionCall}\`.${finalPhaseNote}`;
+        }
+        const validOutcomes = Object.keys(onSuccess)
+            .filter((key) => key !== 'default')
+            .map((key) => `"${key}"`)
+            .join(' | ');
+        return `\n\n---\n\n## Report Back\nWhen this phase is done, call \`seekMentoring({ jobName: "${jobName}", issueNumber: "<issue_number>", currentPhase: "${phaseId}", status: "complete", findings: { issueType: "<outcome>" } })\` with one of: ${validOutcomes}.`;
     }
     /** Phase-authority content injected for all phased workflows. Loaded from orchestration/phase-authority.md. */
     async getPhaseAuthorityContent() {
@@ -95,18 +84,32 @@ class AIMentor {
             return '';
         }
     }
+    getCompactPhaseAuthority() {
+        return AIMentor.COMPACT_PHASE_AUTHORITY;
+    }
     async prependPhaseAuthority(message, isPhased) {
         if (!isPhased)
             return message;
-        const block = await this.getPhaseAuthorityContent();
-        if (!block)
-            return message;
-        return `${block}\n\n---\n\n${message}`;
+        return `${this.getCompactPhaseAuthority()}\n\n${message}`;
+    }
+    buildPhasedJobOverview(workflow) {
+        const metadataPhases = Object.keys(workflow.metadata.phases || {});
+        const initialPhase = workflow.metadata.initialPhase || metadataPhases[0] || Array.from(workflow.phases.keys())[0] || 'starting';
+        const overview = workflow.overview.trim();
+        return [
+            overview,
+            '',
+            '---',
+            '',
+            '## Start Here',
+            `- Initial phase: \`${initialPhase}\``,
+            '- Call `seekMentoring` to load the instructions for this phase.'
+        ].join('\n');
     }
     async generateStartingMessage(workflow, phaseId, skipIncludes) {
         const entityType = 'Job';
         if (workflow.isSimple) {
-            const message = `🚀 **Starting ${entityType}: ${workflow.metadata.name}**\n\n${workflow.overview}`;
+            const message = `Starting ${entityType}: ${workflow.metadata.name}\n\n${workflow.overview}`;
             this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name} (starting)`);
             return {
                 message,
@@ -116,17 +119,14 @@ class AIMentor {
         }
         const isVeryFirstCall = phaseId === 'starting';
         const targetPhase = isVeryFirstCall ? (workflow.metadata.initialPhase || 'starting') : phaseId;
-        let message = '';
-        if (isVeryFirstCall && workflow.overview) {
-            message += `${workflow.overview}\n\n---\n\n`;
-        }
+        let message = `### Current Phase: ${targetPhase}\n\n`;
         let instructions = workflow.phases.get(targetPhase);
         if (instructions) {
             instructions = skipIncludes ? instructions : await this.resolveIncludes(instructions, workflow.path);
-            message += `${instructions}`;
+            message += instructions;
         }
         else {
-            message += `⚠️ No specific instructions found for phase: ${targetPhase}`;
+            message += `No specific instructions found for phase: ${targetPhase}`;
         }
         const phaseFlow = workflow.metadata.phases?.[targetPhase];
         message += this.buildReportBackFooter(workflow.metadata.name, targetPhase, phaseFlow);
@@ -142,7 +142,7 @@ class AIMentor {
     async generateCompletionMessage(workflow, phaseId, findings, evidence, skipIncludes) {
         const entityType = 'Job';
         if (workflow.isSimple) {
-            const message = `✅ **${entityType} Complete: ${workflow.metadata.name}**\n\n🎉 Great work! You have completed the ${workflow.metadata.name} ${entityType.toLowerCase()}.`;
+            const message = `${entityType} Complete: ${workflow.metadata.name}\n\nYou have completed the ${workflow.metadata.name} ${entityType.toLowerCase()}.`;
             this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name} (complete)`);
             return {
                 message,
@@ -158,12 +158,12 @@ class AIMentor {
             }
             else {
                 const outcome = findings?.phaseOutcome ?? findings?.issueType ?? evidence?.issueType ?? evidence?.phaseOutcome ?? 'default';
-                nextPhaseId = phaseFlow.onSuccess[outcome] ?? phaseFlow.onSuccess['default'] ?? null;
+                nextPhaseId = phaseFlow.onSuccess[outcome] ?? phaseFlow.onSuccess.default ?? null;
             }
         }
         let message = '';
         if (nextPhaseId) {
-            message += `Great work. Moving to the next phase: **${nextPhaseId}**.\n\n`;
+            message += `Moving to the next phase: **${nextPhaseId}**.\n\n`;
             let nextInstructions = workflow.phases.get(nextPhaseId);
             if (nextInstructions) {
                 nextInstructions = skipIncludes ? nextInstructions : await this.resolveIncludes(nextInstructions, workflow.path);
@@ -187,7 +187,7 @@ class AIMentor {
     async generateHelpMessage(workflow, phaseId, status, skipIncludes) {
         const entityType = 'Job';
         if (workflow.isSimple) {
-            const message = `**${entityType}: ${workflow.metadata.name}**\n\n${workflow.overview}`;
+            const message = `${entityType}: ${workflow.metadata.name}\n\n${workflow.overview}`;
             this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name} (${status})`);
             return {
                 message,
@@ -214,7 +214,15 @@ class AIMentor {
     }
     async getJobOverview(jobName) {
         const job = await this.getOrLoadJob(jobName);
-        return job ? { overview: job.overview, isSimple: job.isSimple } : null;
+        if (!job)
+            return null;
+        if (job.isSimple) {
+            return { overview: job.overview, isSimple: true };
+        }
+        return {
+            overview: this.buildPhasedJobOverview(job),
+            isSimple: false
+        };
     }
     async getAllJobMetadata() {
         const items = await this.resolver.listItems('job');
@@ -228,3 +236,4 @@ class AIMentor {
     }
 }
 exports.AIMentor = AIMentor;
+AIMentor.COMPACT_PHASE_AUTHORITY = '**Use only the phases defined in this workflow.**';

package/dist/src/core/config-loader.js

@@ -25,6 +25,66 @@ function normalizeCustomerCommunication(config) {
         deliveryProvider: current.deliveryProvider
     };
 }
+function normalizeIntegrations(config) {
+    const current = config?.integrations;
+    if (!current || typeof current !== 'object')
+        return undefined;
+    return {
+        itsm: current.itsm && typeof current.itsm === 'object'
+            ? {
+                provider: current.itsm.provider,
+                instanceUrl: current.itsm.instanceUrl
+            }
+            : undefined,
+        identity: current.identity && typeof current.identity === 'object'
+            ? { provider: current.identity.provider }
+            : undefined
+    };
+}
+function normalizeAutomation(config) {
+    const support = config?.automation?.support;
+    if (!support || typeof support !== 'object')
+        return undefined;
+    return {
+        support: {
+            startMode: support.startMode,
+            defaultDecisionMode: support.defaultDecisionMode,
+            contextResolver: support.contextResolver && typeof support.contextResolver === 'object'
+                ? {
+                    scriptPath: support.contextResolver.scriptPath,
+                    arguments: Array.isArray(support.contextResolver.arguments) ? support.contextResolver.arguments : undefined,
+                    timeoutMs: support.contextResolver.timeoutMs
+                }
+                : undefined,
+            queue: support.queue && typeof support.queue === 'object'
+                ? {
+                    provider: support.queue.provider,
+                    table: support.queue.table,
+                    assignmentGroup: support.queue.assignmentGroup,
+                    claimField: support.queue.claimField,
+                    fixturePath: support.queue.fixturePath,
+                    eligibleStates: Array.isArray(support.queue.eligibleStates) ? support.queue.eligibleStates : undefined,
+                    pollIntervalSeconds: support.queue.pollIntervalSeconds,
+                    successState: support.queue.successState,
+                    failureState: support.queue.failureState,
+                    closeState: support.queue.closeState
+                }
+                : undefined,
+            requestTypes: support.requestTypes && typeof support.requestTypes === 'object'
+                ? support.requestTypes
+                : undefined,
+            communication: support.communication && typeof support.communication === 'object'
+                ? {
+                    channel: support.communication.channel,
+                    deliveryMode: support.communication.deliveryMode,
+                    recipientField: support.communication.recipientField,
+                    includeTemporaryPassword: support.communication.includeTemporaryPassword,
+                    messageTemplate: support.communication.messageTemplate
+                }
+                : undefined
+        }
+    };
+}
 function normalizeFraimConfig(config) {
     // Handle backward compatibility and migration
     const mergedConfig = {
@@ -70,6 +130,14 @@ function normalizeFraimConfig(config) {
     if (customerCommunication) {
         mergedConfig.customerCommunication = customerCommunication;
     }
+    const integrations = normalizeIntegrations(config);
+    if (integrations) {
+        mergedConfig.integrations = integrations;
+    }
+    const automation = normalizeAutomation(config);
+    if (automation) {
+        mergedConfig.automation = automation;
+    }
     return mergedConfig;
 }
 /**