fraim 2.0.166 → 2.0.167

package/dist/src/config/ai-manager-hiring.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUMAN_MANAGER_PROFILES = exports.AI_MANAGER_QUALITIES = exports.HIRING_SERVICES = void 0;
+exports.getHumanManagerProfile = getHumanManagerProfile;
+exports.buildSearchQuery = buildSearchQuery;
+exports.buildJobDescription = buildJobDescription;
+exports.buildServiceUrl = buildServiceUrl;
+exports.buildManagerHiringCatalog = buildManagerHiringCatalog;
+/**
+ * Issue #538 — human-manager hiring engine (app side).
+ *
+ * Self-contained on purpose: the app (AI Hub UI modal + bootstrap) must resolve this
+ * at runtime in every packaging context (dev tsx, compiled dist, packed CLI), so it
+ * must NOT import across the app→registry boundary. The `hire-the-right-human-ai-manager`
+ * job uses the mirror engine `registry/scripts/ai-manager-hiring.ts` (self-contained +
+ * CLI). The two are kept identical by a parity test (tests/isolated/test-538-ai-manager-hiring.ts);
+ * that is the DRY contract — one behavior, enforced, with no fragile cross-boundary import.
+ */
+const persona_hiring_1 = require("./persona-hiring");
+exports.HIRING_SERVICES = ['linkedin', 'indeed', 'seekout'];
+/** The qualities of a strong AI manager — embedded in both the query and the JD. */
+exports.AI_MANAGER_QUALITIES = [
+    { title: 'Clear specification & written communication', detail: 'Can brief an AI agent so it executes correctly the first time.' },
+    { title: 'Trust-but-verify judgment', detail: 'Knows when to delegate to the agent and when to review deeply.' },
+    { title: 'Coaching mindset', detail: 'Gives feedback that compounds into reusable rules and learnings.' },
+    { title: 'Outcome ownership & AI fluency', detail: 'Owns results; comfortable directing autonomous agents.' },
+];
+const GENERALIST_PROFILE = {
+    humanTitle: 'Manager',
+    keywords: ['"Manager"', '"Director"', '"Team Lead"', '"Chief of Staff"'],
+};
+/** Role key -> the human manager best suited to manage that AI employee. Mirror of registry/scripts/ai-manager-hiring.ts. */
+exports.HUMAN_MANAGER_PROFILES = {
+    maestro: { humanTitle: 'Co-Founder / General Manager', keywords: ['"Co-Founder"', '"General Manager"', '"Chief of Staff"', '"Founder"'] },
+    beza: { humanTitle: 'Head of Strategy', keywords: ['"Head of Strategy"', '"Strategy Director"', '"Chief of Staff"'] },
+    pam: { humanTitle: 'Head of Product', keywords: ['"Head of Product"', '"Group Product Manager"', '"Director of Product"'] },
+    swen: { humanTitle: 'Engineering Manager', keywords: ['"Engineering Manager"', '"Tech Lead"', '"Staff Software Engineer"'] },
+    qasm: { humanTitle: 'QA Manager', keywords: ['"QA Manager"', '"QA Lead"', '"Head of Quality"'] },
+    huxley: { humanTitle: 'Design Manager', keywords: ['"Design Manager"', '"Head of Design"', '"Design Lead"'] },
+    gautam: { humanTitle: 'Marketing Director', keywords: ['"Head of Growth"', '"Marketing Director"', '"Demand Generation Lead"'] },
+    cela: { humanTitle: 'General Counsel', keywords: ['"General Counsel"', '"Head of Legal"', '"Legal Director"'] },
+    sekhar: { humanTitle: 'Security Manager', keywords: ['"Security Manager"', '"Head of Security"', '"CISO"'] },
+    ashley: { humanTitle: 'Chief of Staff', keywords: ['"Chief of Staff"', '"Executive Operations Manager"', '"Office Manager"'] },
+    mandy: { humanTitle: 'Head of Operations', keywords: ['"Head of Operations"', '"Director of Operations"', '"Program Manager"'] },
+    ricardo: { humanTitle: 'Recruiting Manager', keywords: ['"Recruiting Manager"', '"Head of Talent"', '"Talent Acquisition Lead"'] },
+    hari: { humanTitle: 'HR Manager', keywords: ['"HR Manager"', '"Head of People"', '"HR Business Partner"'] },
+    careena: { humanTitle: 'Head of Talent Development', keywords: ['"Head of Talent Development"', '"L&D Manager"', '"Career Coaching Lead"'] },
+    sade: { humanTitle: 'Salesforce Manager', keywords: ['"Salesforce Manager"', '"CRM Lead"', '"Salesforce Architect"'] },
+    sam: { humanTitle: 'Sales Manager', keywords: ['"Sales Manager"', '"Head of Sales"', '"Director of Sales"'] },
+    casey: { humanTitle: 'Customer Success Manager', keywords: ['"Customer Success Manager"', '"Head of Customer Success"', '"Support Manager"'] },
+    deidre: { humanTitle: 'Head of DEI', keywords: ['"Head of DEI"', '"Director of Inclusion"', '"DEI Program Manager"'] },
+    mona: { humanTitle: 'Finance Manager', keywords: ['"Finance Manager"', '"Head of Finance"', '"Controller"'] },
+    sreya: { humanTitle: 'SRE Manager', keywords: ['"SRE Manager"', '"Head of Reliability"', '"Platform Engineering Lead"'] },
+    procella: { humanTitle: 'Procurement Manager', keywords: ['"Procurement Manager"', '"Head of Procurement"', '"Sourcing Lead"'] },
+    banke: { humanTitle: 'KYC Operations Manager', keywords: ['"KYC Operations Manager"', '"AML Compliance Manager"', '"Banking Compliance Lead"'] },
+    auditya: { humanTitle: 'Audit Manager', keywords: ['"Audit Manager"', '"Internal Audit Lead"', '"Compliance Audit Manager"'] },
+};
+function getHumanManagerProfile(roleKey) {
+    return exports.HUMAN_MANAGER_PROFILES[roleKey] ?? GENERALIST_PROFILE;
+}
+const AI_MANAGER_QUERY_TERMS = '("AI" OR "LLM" OR "agentic") AND ("coaching" OR "mentoring")';
+function buildSearchQuery(roleKey) {
+    const profile = getHumanManagerProfile(roleKey);
+    return `${profile.keywords.join(' OR ')} AND ${AI_MANAGER_QUERY_TERMS}`;
+}
+function buildJobDescription(roleKey) {
+    const profile = getHumanManagerProfile(roleKey);
+    const role = persona_hiring_1.PERSONA_HIRE_CATALOG[roleKey]?.role ?? 'AI Employee';
+    return [
+        `${profile.humanTitle} — manager for an ${role}`,
+        '',
+        `You will manage an ${role} (an autonomous AI agent) and the humans around it, owning the outcomes it ships.`,
+        '',
+        "What you'll do:",
+        `- Write crisp specifications and acceptance criteria the ${role} can execute against.`,
+        `- Review the agent's output with judgment: know when to trust it and when to dig in.`,
+        '- Coach the agent and team so feedback compounds into reusable rules.',
+        '- Own delivery outcomes, not activity; prioritize ruthlessly.',
+        '',
+        'What makes a strong AI manager:',
+        ...exports.AI_MANAGER_QUALITIES.map((q) => `- ${q.title}: ${q.detail}`),
+    ].join('\n');
+}
+function buildServiceUrl(service, query, location) {
+    const q = encodeURIComponent(query);
+    const loc = location && location.trim().length > 0 ? location.trim() : '';
+    switch (service) {
+        case 'linkedin':
+            return `https://www.linkedin.com/search/results/people/?keywords=${q}`;
+        case 'indeed':
+            return `https://www.indeed.com/jobs?q=${q}${loc ? `&l=${encodeURIComponent(loc)}` : ''}`;
+        case 'seekout':
+            return 'https://app.seekout.com/';
+    }
+}
+/**
+ * Catalog projection for the AI Hub bootstrap so the client renders off the server's
+ * source of truth. Defaults to exactly the hireable personas in `PERSONA_HIRE_CATALOG`.
+ */
+function buildManagerHiringCatalog(roleKeys = Object.keys(persona_hiring_1.PERSONA_HIRE_CATALOG)) {
+    const roles = {};
+    for (const key of roleKeys) {
+        const profile = getHumanManagerProfile(key);
+        const query = buildSearchQuery(key);
+        // managedRole is derived from PERSONA_HIRE_CATALOG so the bootstrap response
+        // shape is unchanged even after removing the field from HumanManagerProfile.
+        const managedRole = persona_hiring_1.PERSONA_HIRE_CATALOG[key]?.role ?? 'AI Employee';
+        roles[key] = {
+            ...profile,
+            managedRole,
+            query,
+            jobDescription: buildJobDescription(key),
+            serviceUrls: {
+                linkedin: buildServiceUrl('linkedin', query),
+                indeed: buildServiceUrl('indeed', query),
+                seekout: buildServiceUrl('seekout', query),
+            },
+        };
+    }
+    return { qualities: exports.AI_MANAGER_QUALITIES, services: exports.HIRING_SERVICES, roles };
+}

package/dist/src/config/compat.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Compatibility configuration for FRAIM.
+ * This file defines breaking changes and minimum required versions for clients.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBreakingChangesNotice = exports.MINIMUM_CLIENT_VERSION = void 0;
+exports.MINIMUM_CLIENT_VERSION = '2.0.94';
+/**
+ * Notice template for clients running outdated versions.
+ * This is appended to tool responses to guide users toward the standardized setup.
+ */
+const getBreakingChangesNotice = (currentVersion) => {
+    return `\n\n---\n\n> [!WARNING] migration_notice\n> **Action Required**: You are using an outdated FRAIM configuration (v${currentVersion}). FRAIM requires at least v${exports.MINIMUM_CLIENT_VERSION}.\n> \n> To fix this permanently so you never have to update again, please run this terminal command **once**:\n> \`\`\`bash\n> npx fraim@latest setup\n> \`\`\`\n> Then restart your IDE.`;
+};
+exports.getBreakingChangesNotice = getBreakingChangesNotice;

package/dist/src/config/feature-flags.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFeatureFlags = getFeatureFlags;
+exports.isPersonaEntitlementsEnabled = isPersonaEntitlementsEnabled;
+exports.getPublicFeatureFlags = getPublicFeatureFlags;
+function parseBooleanFlag(value) {
+    if (!value)
+        return false;
+    return ['1', 'true', 'yes', 'on'].includes(value.trim().toLowerCase());
+}
+function getFeatureFlags() {
+    return {
+        personaEntitlements: {
+            enabled: parseBooleanFlag(process.env.FRAIM_FF_PERSONA_ENTITLEMENTS)
+        }
+    };
+}
+function isPersonaEntitlementsEnabled() {
+    return getFeatureFlags().personaEntitlements.enabled;
+}
+function getPublicFeatureFlags() {
+    return {
+        personaEntitlementsEnabled: isPersonaEntitlementsEnabled()
+    };
+}

package/dist/src/config/persona-capability-bundles.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERSONA_CAPABILITY_BUNDLES = exports.FREE_JOBS = void 0;
+exports.isFreeJob = isFreeJob;
+exports.getPersonaCapabilityBundle = getPersonaCapabilityBundle;
+exports.getProtectedPersonaForJob = getProtectedPersonaForJob;
+exports.listPersonaCapabilityBundles = listPersonaCapabilityBundles;
+const persona_hiring_1 = require("./persona-hiring");
+const persona_catalog_routes_1 = require("../routes/persona-catalog-routes");
+exports.FREE_JOBS = new Set([
+    'create-architecture', 'project-scaffolding',
+    'blue-sky-brainstorming', 'codebase-analysis-and-ideation',
+    'domain-registration-research', 'google-workspace-setup', 'github-org-setup',
+    'contribute-to-fraim', 'file-fraim-issue', 'praise-fraim',
+]);
+function isFreeJob(jobName) {
+    return exports.FREE_JOBS.has(jobName);
+}
+function buildCatalogMetadata(personaKey, sampleJobs) {
+    const persona = persona_hiring_1.PERSONA_HIRE_CATALOG[personaKey];
+    const pricingLabel = `${(0, persona_catalog_routes_1.formatPrice)(persona.jobPriceCents)}/job or ${(0, persona_catalog_routes_1.formatPrice)(persona.fulltimePriceCents)}/mo`;
+    return {
+        displayName: persona.displayName,
+        role: persona.role,
+        pricingLabel,
+        sampleJobs
+    };
+}
+exports.PERSONA_CAPABILITY_BUNDLES = {
+    maestro: {
+        personaKey: 'maestro',
+        bundleId: 'persona-maestro-core',
+        catalogMetadata: buildCatalogMetadata('maestro', ['feature-implementation', 'review-business-strategy', 'security-review', 'contract-review-analysis']),
+        protectedJobs: [],
+        protectedAliases: ['maestro', 'founder-mode'],
+        defaultHireMode: 'fulltime',
+        lockCopy: 'Hire Maestro to unlock full-brained AI employee capabilities across every function.'
+    },
+    beza: {
+        personaKey: 'beza',
+        bundleId: 'persona-beza-core',
+        catalogMetadata: buildCatalogMetadata('beza', ['review-business-strategy', 'business-plan-creation', 'problem-statement-crystallization']),
+        protectedJobs: ['review-business-strategy', 'business-plan-creation', 'problem-statement-crystallization', 'business-idea-validation-and-scoping', 'founder-market-fit-analysis', 'rfp-response-preparation', 'aws-activate-credits-application', 'community-funding-preparation', 'fundraising-prospect-discovery', 'google-cloud-credits-application', 'investor-pitch-preparation', 'microsoft-azure-credits-application', 'review-funding-preparation', 'advisory-board-development', 'advisor-interview', 'advisory-board-selection'],
+        protectedAliases: ['business-strategy', 'company-strategy'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire BeZa to unlock business strategy work for this request.'
+    },
+    pam: {
+        personaKey: 'pam',
+        bundleId: 'persona-pam-core',
+        catalogMetadata: buildCatalogMetadata('pam', ['feature-specification', 'technical-design', 'issue-preparation']),
+        protectedJobs: ['feature-specification', 'technical-design', 'issue-preparation', 'implementation-design-review', 'issue-retrospective', 'work-completion', 'scrum-sprint-planning', 'mvp-validation-plan'],
+        protectedAliases: ['product-management', 'product-spec'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire PaM to unlock product-management work for this request.'
+    },
+    swen: {
+        personaKey: 'swen',
+        bundleId: 'persona-swen-core',
+        catalogMetadata: buildCatalogMetadata('swen', ['feature-implementation', 'code-refactoring', 'pr-iteration']),
+        protectedJobs: ['feature-implementation', 'code-refactoring', 'pr-iteration', 'mobile-app-development', 'mcp-server-creation', 'cloud-application-deployment', 'cloud-cost-optimization', 'cloud-performance-diagnosis', 'route-llm-spend-to-cloud-credits', 'set-up-cloud-cost-alerts', 'gitlabs-to-github', 'system-migration', 'cross-cloud-migration', 'data-pipeline-design', 'data-quality-monitoring', 'data-platform-architecture', 'write-dev-docs', 'database-schema-design'],
+        protectedAliases: ['software-engineering', 'implementation'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire SWEn to unlock software-engineering delivery for this request.'
+    },
+    qasm: {
+        personaKey: 'qasm',
+        bundleId: 'persona-qasm-core',
+        catalogMetadata: buildCatalogMetadata('qasm', ['test-execution', 'browser-application-validation', 'ui-polish-validation']),
+        protectedJobs: ['test-execution', 'browser-application-validation', 'ui-polish-validation', 'code-quality-assessment', 'test-quality-assessment', 'user-testing-and-bug-bash', 'broken-windows-detection-and-remediation', 'iterative-quality-improvement', 'implementation-feature-review', 'accessibility-audit', 'api-testing', 'performance-benchmarking'],
+        protectedAliases: ['qa', 'quality-assurance'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire QAsm to unlock QA validation for this request.'
+    },
+    huxley: {
+        personaKey: 'huxley',
+        bundleId: 'persona-huxley-core',
+        catalogMetadata: buildCatalogMetadata('huxley', ['design-system-creation', 'user-facing-prototyping', 'ux-research-synthesis']),
+        protectedJobs: ['design-system-creation', 'user-facing-prototyping', 'website-creation', 'linkedin-carousel-from-deck', 'brand-creation', 'branding-quality-audit', 'ux-research-synthesis', 'user-journey-mapping'],
+        protectedAliases: ['ux-design', 'brand-design'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire hUXley to unlock design-system, UX research, and brand design work for this request.'
+    },
+    gautam: {
+        personaKey: 'gautam',
+        bundleId: 'persona-gautam-core',
+        catalogMetadata: buildCatalogMetadata('gautam', ['analyze-revenue-system', 'build-gtm-motion', 'ppc-campaign-management']),
+        protectedJobs: ['pricing-strategy-definition', 'marketing-strategy-definition', 'product-launch-management', 'customer-prospect-discovery', 'evangelist-content-development', 'funnel-analysis', 'growth-loop-design', 'analyze-revenue-system', 'design-gtm-system', 'build-gtm-motion', 'build-gtm-stack', 'plan-gtm-team', 'marketing-content-creation', 'ppc-campaign-management', 'paid-social-strategy', 'ad-performance-analysis', 'tracking-and-attribution-setup', 'developer-advocacy', 'seo-strategy', 'marketing-analytics-review'],
+        protectedAliases: ['gtm', 'marketing'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire GauTaM to unlock go-to-market and paid media work for this request.'
+    },
+    cela: {
+        personaKey: 'cela',
+        bundleId: 'persona-cela-core',
+        catalogMetadata: buildCatalogMetadata('cela', ['contract-review-analysis', 'nda-creation', 'saas-contract-package-creation']),
+        protectedJobs: ['contract-review-analysis', 'nda-creation', 'saas-contract-package-creation', 'trademark-registration-management', 'provisional-patent-application-creation', 'opensign-cloud-esign-dispatch', 'w9-creation', 'invoice-generation', 'entity-type-selection', 'state-incorporation-filing', 'business-tax-registration', 'ein-application', 'cap-table-construction', 'founder-and-equity-agreements', 'ip-assignment-agreement-creation', 'employment-structure-decision', 'business-banking-setup'],
+        protectedAliases: ['legal', 'counsel'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire CELiA to unlock legal workflow support for this request.'
+    },
+    sekhar: {
+        personaKey: 'sekhar',
+        bundleId: 'persona-sekhar-core',
+        catalogMetadata: buildCatalogMetadata('sekhar', ['security-review', 'ai-native-security-setup', 'security-findings-command-center']),
+        protectedJobs: ['security-review', 'ai-native-security-setup', 'security-findings-command-center', 'vulnerability-triage-and-remediation', 'production-readiness-review', 'compliance-review', 'compliance-continuous-monitoring', 'compliance-policy-authoring', 'compliance-questionnaire-response', 'compliance-requirements-detection', 'generate-audit-evidence', 'regulation-evidence-management', 'soc2-evidence-management'],
+        protectedAliases: ['security', 'appsec'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire SEChar to unlock security setup, review, and findings-command work for this request.'
+    },
+    ashley: {
+        personaKey: 'ashley',
+        bundleId: 'persona-ashley-core',
+        catalogMetadata: buildCatalogMetadata('ashley', ['executive-assistant', 'weekly-operating-review', 'send-thank-you-notes']),
+        protectedJobs: ['executive-assistant', 'weekly-operating-review', 'send-thank-you-notes', 'send-newsletter', 'analyze-transcript', 'send-stakeholder-update', 'portfolio-impact-report'],
+        protectedAliases: ['executive-assistant', 'operations-assistant'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire AshLey to unlock executive-assistant work for this request.'
+    },
+    mandy: {
+        personaKey: 'mandy',
+        bundleId: 'persona-mandy-core',
+        catalogMetadata: buildCatalogMetadata('mandy', ['fully-delegate', 'project-plan-creation', 'stakeholder-status-reporting']),
+        protectedJobs: ['fully-delegate', 'delivery-governance-review', 'project-plan-creation', 'stakeholder-status-reporting', 'experiment-tracking', 'cross-functional-dependency-management'],
+        protectedAliases: ['manager', 'team-lead', 'orchestrator'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire MANdy to unlock autonomous multi-role orchestration — MANdy plans the job sequence, runs sub-agents in parallel, coaches them through verification loops, and hands back a synthesized DRAFT for your approval.'
+    },
+    ricardo: {
+        personaKey: 'ricardo',
+        bundleId: 'persona-ricardo-core',
+        catalogMetadata: buildCatalogMetadata('ricardo', ['role-intake-and-scorecard', 'job-posting-and-sourcing', 'candidate-pipeline-management']),
+        protectedJobs: ['role-intake-and-scorecard', 'job-posting-and-sourcing', 'candidate-pipeline-management', 'interview-coordination', 'offer-and-close-management'],
+        protectedAliases: ['recruiting', 'recruiter', 'hiring'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire RECardo to unlock full-cycle recruiting work for this request.'
+    },
+    hari: {
+        personaKey: 'hari',
+        bundleId: 'persona-hari-core',
+        catalogMetadata: buildCatalogMetadata('hari', ['new-hire-onboarding', 'performance-review-preparation', 'benefits-analysis-and-enrollment']),
+        protectedJobs: ['new-hire-onboarding', 'performance-review-preparation', 'benefits-analysis-and-enrollment', 'payroll-coordination', 'hr-business-partner-advisory'],
+        protectedAliases: ['hr', 'human-resources', 'people-ops'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire HaRi to unlock HR and people-ops work for this request.'
+    },
+    careena: {
+        personaKey: 'careena',
+        bundleId: 'persona-careena-core',
+        catalogMetadata: buildCatalogMetadata('careena', ['job-application-execution', 'pitch-and-interview-prep', 'career-networking']),
+        protectedJobs: ['career-spec', 'job-application-execution', 'resume-creation', 'public-profile-updates', 'career-trajectory-planning', 'pitch-and-interview-prep', 'career-networking', 'offer-negotiation', 'resilience-planning'],
+        protectedAliases: ['career', 'career-coach', 'job-search'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire CAREEna to unlock job-search execution, interview prep, and career coaching for this request.'
+    },
+    sade: {
+        personaKey: 'sade',
+        bundleId: 'persona-sade-core',
+        catalogMetadata: buildCatalogMetadata('sade', ['sf-config-deployment', 'sf-build-dashboard', 'sf-build-automation']),
+        protectedJobs: ['sf-config-deployment', 'sf-build-dashboard', 'sf-build-automation', 'sf-org-health-check', 'sf-user-and-access-management', 'sf-data-management'],
+        protectedAliases: ['salesforce', 'salesforce-developer', 'salesforce-admin'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire SADE to unlock Salesforce development and administration work for this request.'
+    },
+    sam: {
+        personaKey: 'sam',
+        bundleId: 'persona-sam-core',
+        catalogMetadata: buildCatalogMetadata('sam', ['crm-pipeline-review', 'outbound-sales-strategy', 'discovery-coaching']),
+        protectedJobs: ['crm-pipeline-review', 'outbound-sales-strategy', 'discovery-coaching', 'deal-strategy', 'proposal-development', 'account-strategy', 'sales-coaching'],
+        protectedAliases: ['sales', 'sales-manager', 'account-manager', 'pipeline'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire SAM to unlock full-cycle sales work for this request.'
+    },
+    casey: {
+        personaKey: 'casey',
+        bundleId: 'persona-casey-core',
+        catalogMetadata: buildCatalogMetadata('casey', ['support-case-resolution', 'support-sop-operationalization', 'support-system-operationalization', 'support-playbook-evaluation']),
+        protectedJobs: ['crm-account-health-review', 'crm-case-resolution', 'customer-health-review', 'loyalty-program-management', 'survey-campaign-management', 'support-queue-management', 'support-case-resolution', 'support-sop-operationalization', 'support-system-operationalization', 'support-playbook-evaluation'],
+        protectedAliases: ['customer-success', 'customer-support', 'csm', 'support'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire CaSey to unlock customer success and support work for this request.'
+    },
+    deidre: {
+        personaKey: 'deidre',
+        bundleId: 'persona-deidre-core',
+        catalogMetadata: buildCatalogMetadata('deidre', [
+            'dei-toolkit-creation',
+            'equity-pattern-analysis',
+            'ai-governance-for-inclusion'
+        ]),
+        protectedJobs: [
+            'dei-toolkit-creation',
+            'equity-pattern-analysis',
+            'ai-governance-for-inclusion',
+            'ai-fluency-program-design',
+            'executive-order-dei-impact-analysis',
+            'erg-sop-modernization',
+            'inclusion-ai-readiness-audit'
+        ],
+        protectedAliases: ['dei', 'inclusion', 'diversity', 'equity', 'erg', 'inclusion-leader'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire DEIdre to unlock equity and inclusion work for this request.'
+    },
+    mona: {
+        personaKey: 'mona',
+        bundleId: 'persona-mona-core',
+        catalogMetadata: buildCatalogMetadata('mona', ['financial-analysis', 'fpa-and-forecasting', 'monthly-close-review']),
+        protectedJobs: ['financial-analysis', 'fpa-and-forecasting', 'monthly-close-review', 'tax-strategy-planning'],
+        protectedAliases: ['finance', 'financial-modeling', 'fpa', 'bookkeeping'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire MONa to unlock financial modeling, FP&A, and tax strategy work for this request.'
+    },
+    sreya: {
+        personaKey: 'sreya',
+        bundleId: 'persona-sreya-core',
+        catalogMetadata: buildCatalogMetadata('sreya', ['slo-design-and-implementation', 'incident-response', 'reliability-review']),
+        protectedJobs: ['slo-design-and-implementation', 'incident-response', 'reliability-review'],
+        protectedAliases: ['sre', 'reliability', 'incident-response', 'on-call'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire SREya to unlock SLO governance, incident response, and production reliability work for this request.'
+    },
+    procella: {
+        personaKey: 'procella',
+        bundleId: 'persona-procella-core',
+        catalogMetadata: buildCatalogMetadata('procella', ['procurement-intake-and-strategy', 'rfx-package-authoring', 'proposal-response-evaluation']),
+        protectedJobs: [
+            'procurement-intake-and-strategy',
+            'supplier-discovery-and-qualification',
+            'rfx-package-authoring',
+            'proposal-response-evaluation',
+            'procurement-negotiation-prep',
+            'purchase-approval-and-po-package',
+            'equipment-acceptance-and-supplier-retrospective',
+            'supplier-performance-review'
+        ],
+        protectedAliases: ['procurement', 'sourcing', 'purchasing', 'supplier-management'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire PROCella to unlock procurement strategy, supplier sourcing, RFx, quote evaluation, and supplier performance work for this request.'
+    },
+    banke: {
+        personaKey: 'banke',
+        bundleId: 'persona-banke-core',
+        catalogMetadata: buildCatalogMetadata('banke', ['kyc-case-review']),
+        protectedJobs: ['kyc-case-review'],
+        protectedAliases: ['banking', 'kyc', 'account-aggregator'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire BANKe to unlock banking KYC evidence review work for this request.'
+    },
+    auditya: {
+        personaKey: 'auditya',
+        bundleId: 'persona-auditya-core',
+        catalogMetadata: buildCatalogMetadata('auditya', ['banking-evidence-audit']),
+        protectedJobs: ['banking-evidence-audit'],
+        protectedAliases: ['banking-audit', 'kyc-audit', 'audit'],
+        defaultHireMode: 'job',
+        lockCopy: 'Hire AUDITya to unlock banking evidence audit work for this request.'
+    }
+};
+const PROTECTED_JOB_TO_PERSONA = new Map();
+for (const bundle of Object.values(exports.PERSONA_CAPABILITY_BUNDLES)) {
+    for (const jobName of bundle.protectedJobs) {
+        PROTECTED_JOB_TO_PERSONA.set(jobName, bundle.personaKey);
+    }
+}
+function getPersonaCapabilityBundle(personaKey) {
+    return exports.PERSONA_CAPABILITY_BUNDLES[personaKey];
+}
+function getProtectedPersonaForJob(jobName) {
+    return PROTECTED_JOB_TO_PERSONA.get(jobName) || null;
+}
+function listPersonaCapabilityBundles() {
+    return Object.values(exports.PERSONA_CAPABILITY_BUNDLES);
+}