fraim 2.0.362-next.4 → 2.0.362

package/dist/registry/domains.json

@@ -1,159 +0,0 @@
-{
-  "schemaVersion": 2,
-  "mapVersion": 3,
-  "domains": {
-    "global": {
-      "purpose": "Shared integrity, authority, communication and evidence mandates",
-      "rules": [
-        "rules/constitution.md",
-        "rules/evidence-cardinality.md"
-      ]
-    },
-    "ai-engineering": {
-      "purpose": "Build and validate AI systems",
-      "rules": [
-        "rules/ai-engineering/ai-engineering.md"
-      ]
-    },
-    "bank-compliance": {
-      "purpose": "Review banking compliance evidence",
-      "rules": [
-        "rules/bank-compliance/bank-compliance.md"
-      ]
-    },
-    "bank-operations": {
-      "purpose": "Prepare banking and KYC operations",
-      "rules": [
-        "rules/bank-operations/bank-operations.md"
-      ]
-    },
-    "career": {
-      "purpose": "Support professional development",
-      "rules": []
-    },
-    "customer": {
-      "purpose": "Support customer relationships and systems",
-      "rules": [
-        "rules/customer/customer.md"
-      ]
-    },
-    "design": {
-      "purpose": "Create and evaluate user experiences and brand systems",
-      "rules": [
-        "rules/design/design.md"
-      ]
-    },
-    "dev-ops": {
-      "purpose": "Operate infrastructure and production services",
-      "rules": [
-        "rules/dev-ops/dev-ops.md"
-      ]
-    },
-    "engineering": {
-      "purpose": "Implement and maintain software",
-      "rules": [
-        "rules/engineering/engineering.md"
-      ]
-    },
-    "executive-assistance": {
-      "purpose": "Support executive coordination",
-      "rules": []
-    },
-    "finance": {
-      "purpose": "Analyze finances and prepare funding",
-      "rules": [
-        "rules/finance/finance.md"
-      ]
-    },
-    "fraim": {
-      "purpose": "Author and maintain FRAIM capabilities",
-      "rules": [
-        "rules/fraim/artifact-boundaries.md"
-      ]
-    },
-    "go-to-market": {
-      "purpose": "Plan and execute market positioning, demand and launches",
-      "rules": [
-        "rules/go-to-market/go-to-market.md"
-      ]
-    },
-    "inclusion": {
-      "purpose": "Evaluate inclusion policy and workforce evidence",
-      "rules": [
-        "rules/inclusion/inclusion.md"
-      ]
-    },
-    "legal": {
-      "purpose": "Prepare legal analysis and filings for qualified review",
-      "rules": [
-        "rules/legal/legal.md"
-      ]
-    },
-    "management": {
-      "purpose": "Coordinate people and work",
-      "rules": []
-    },
-    "people-ops": {
-      "purpose": "Support workforce operations",
-      "rules": [
-        "rules/people-ops/people-ops.md"
-      ]
-    },
-    "procurement": {
-      "purpose": "Evaluate suppliers and prepare purchasing decisions",
-      "rules": [
-        "rules/procurement/procurement.md"
-      ]
-    },
-    "product": {
-      "purpose": "Define and validate customer outcomes",
-      "rules": [
-        "rules/product/product.md"
-      ]
-    },
-    "project-management": {
-      "purpose": "Plan and govern delivery",
-      "rules": [
-        "rules/project-management/project-management.md"
-      ]
-    },
-    "quality-assurance": {
-      "purpose": "Validate product behavior and quality",
-      "rules": [
-        "rules/quality-assurance/quality-assurance.md"
-      ]
-    },
-    "recruiting": {
-      "purpose": "Source and assess candidates",
-      "rules": [
-        "rules/recruiting/recruiting.md"
-      ]
-    },
-    "sales": {
-      "purpose": "Advance named customer opportunities and commercial deals",
-      "rules": [
-        "rules/sales/sales.md"
-      ]
-    },
-    "salesforce": {
-      "purpose": "Configure Salesforce workflows and data",
-      "rules": [
-        "rules/salesforce/salesforce.md"
-      ]
-    },
-    "security": {
-      "purpose": "Assess security and compliance controls",
-      "rules": [
-        "rules/security/security.md"
-      ]
-    },
-    "strategy": {
-      "purpose": "Develop organizational strategy",
-      "rules": []
-    },
-    "travel": {
-      "purpose": "Plan travel",
-      "rules": []
-    }
-  }
-}

package/dist/registry/scripts/domains/catalog.js

@@ -1,112 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSafeRegistryPath = isSafeRegistryPath;
-exports.jobDomainFromRegistryPath = jobDomainFromRegistryPath;
-exports.validateDomainCatalog = validateDomainCatalog;
-exports.mergeDomainCatalog = mergeDomainCatalog;
-exports.selectCatalogDomain = selectCatalogDomain;
-function hasOwn(value, key) {
-    return Object.prototype.hasOwnProperty.call(value, key);
-}
-function isSafeDomainId(domain) {
-    return /^[a-z][a-z-]*$/.test(domain) && !['__proto__', 'constructor', 'prototype'].includes(domain);
-}
-function isSafeRegistryPath(value, kind) {
-    return typeof value === 'string' && new RegExp(`^${kind}/[a-zA-Z0-9_/-]+\\.md$`).test(value)
-        && !value.includes('//') && !value.split('/').some(part => part === '.' || part === '..');
-}
-/** Extract a folder, never a frontmatter declaration, leaf-name alias or employee. */
-function jobDomainFromRegistryPath(path) {
-    if (typeof path !== 'string')
-        return null;
-    const clean = path.replace(/\\/g, '/').replace(/^registry\//, '');
-    if (!isSafeRegistryPath(clean, 'jobs'))
-        return null;
-    const rolePath = /^jobs\/(?:ai-employee|ai-manager|personalized-employee)\//.test(clean);
-    const match = clean.match(rolePath
-        ? /^jobs\/(?:ai-employee|ai-manager|personalized-employee)\/([a-z][a-z-]*)\/[^/]+\.md$/
-        : /^jobs\/([a-z][a-z-]*)\/[^/]+\.md$/);
-    return match && isSafeDomainId(match[1]) ? match[1] : null;
-}
-function validateDomainCatalog(value) {
-    const errors = [];
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return ['Catalog must be an object'];
-    const catalog = value;
-    if (catalog.schemaVersion !== 2)
-        errors.push('Unsupported catalog schemaVersion');
-    if (!Number.isInteger(catalog.mapVersion) || catalog.mapVersion < 3)
-        errors.push('Invalid catalog mapVersion');
-    if (hasOwn(catalog, 'unmigratedJobs'))
-        errors.push('Job rollout lists are obsolete; folders own domains');
-    if (!hasOwn(catalog, 'domains') || !catalog.domains || typeof catalog.domains !== 'object' || Array.isArray(catalog.domains))
-        return [...errors, 'Missing domains'];
-    if (!hasOwn(catalog.domains, 'global'))
-        errors.push('Missing global domain');
-    for (const [domain, definition] of Object.entries(catalog.domains)) {
-        if (!isSafeDomainId(domain))
-            errors.push(`Invalid domain: ${domain}`);
-        if (!definition || typeof definition !== 'object' || Array.isArray(definition)) {
-            errors.push(`Invalid definition: ${domain}`);
-            continue;
-        }
-        if (hasOwn(definition, 'jobs'))
-            errors.push(`Job membership is obsolete: ${domain}`);
-        if (!hasOwn(definition, 'purpose') || typeof definition.purpose !== 'string' || !definition.purpose.trim())
-            errors.push(`Missing purpose: ${domain}`);
-        if (!hasOwn(definition, 'rules') || !Array.isArray(definition.rules))
-            errors.push(`Missing rules: ${domain}`);
-        else {
-            const paths = new Set();
-            for (const rule of definition.rules) {
-                if (!isSafeRegistryPath(rule, 'rules'))
-                    errors.push(`Invalid rule path: ${rule}`);
-                if (paths.has(rule))
-                    errors.push(`Duplicate rule: ${rule}`);
-                paths.add(rule);
-            }
-            if (domain === 'global' && !paths.has('rules/constitution.md'))
-                errors.push('Global rules must include the constitution');
-        }
-    }
-    return errors;
-}
-/** Authorized overlays configure rules; they cannot reassign a job or employee. */
-function mergeDomainCatalog(base, extension) {
-    const baseErrors = validateDomainCatalog(base);
-    if (baseErrors.length)
-        throw new Error(baseErrors.join('; '));
-    if (!extension || typeof extension !== 'object' || Array.isArray(extension)
-        || !hasOwn(extension, 'domains') || !extension.domains || typeof extension.domains !== 'object' || Array.isArray(extension.domains)) {
-        throw new Error('Catalog extension must define domains');
-    }
-    if (extension.schemaVersion !== undefined && extension.schemaVersion !== 2)
-        throw new Error('Unsupported catalog extension schemaVersion');
-    if (hasOwn(extension, 'unmigratedJobs'))
-        throw new Error('Job rollout lists are obsolete; folders own domains');
-    const result = JSON.parse(JSON.stringify(base));
-    for (const [domain, definition] of Object.entries(extension.domains)) {
-        if (!isSafeDomainId(domain))
-            throw new Error(`Invalid domain: ${domain}`);
-        if (!definition || typeof definition !== 'object' || Array.isArray(definition))
-            throw new Error(`Invalid definition: ${domain}`);
-        result.domains[domain] = { ...(hasOwn(result.domains, domain) ? result.domains[domain] : {}), ...definition };
-    }
-    if (extension.mapVersion !== undefined)
-        result.mapVersion = extension.mapVersion;
-    const errors = validateDomainCatalog(result);
-    if (errors.length)
-        throw new Error(errors.join('; '));
-    return result;
-}
-function selectCatalogDomain(catalog, jobPath) {
-    // A broken sibling rule list must not change this job's folder identity.
-    if (!catalog || catalog.schemaVersion !== 2 || !catalog.domains || typeof catalog.domains !== 'object'
-        || Array.isArray(catalog.domains))
-        return { domain: null, selection: 'unknown' };
-    if (!jobPath)
-        return { domain: 'global', selection: 'connect' };
-    const domain = jobDomainFromRegistryPath(jobPath);
-    return domain && hasOwn(catalog.domains, domain)
-        ? { domain, selection: 'mapped' } : { domain: null, selection: 'unknown' };
-}