fraim 2.0.362-next.4 → 2.0.362

package/dist/src/core/utils/domain-rule-assembler.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withRuleDeliveryTimeout = withRuleDeliveryTimeout;
 exports.assembleDomainRules = assembleDomainRules;
-exports.attachRuleAssembly = attachRuleAssembly;
+exports.appendRuleInstructions = appendRuleInstructions;
 const crypto_1 = require("crypto");
-const catalog_1 = require("../../../registry/scripts/domains/catalog");
+const folders_1 = require("../../../registry/scripts/domains/folders");
+const include_resolver_1 = require("./include-resolver");
 const inheritance_parser_1 = require("./inheritance-parser");
 class RuleFetchTimeout extends Error {
 }
@@ -31,176 +32,100 @@ async function withRuleDeliveryTimeout(operation, timeoutMs = 5000) {
 async function assembleDomainRules(options) {
     const timeoutMs = Math.max(1, Math.min(options.timeoutMs ?? 5000, 30000));
     const metadata = {
-        domain: options.jobPath ? null : 'global', catalogVersion: null,
+        domain: options.jobPath ? (0, folders_1.jobDomainFromRegistryPath)(options.jobPath) : 'global',
         selection: options.jobPath ? 'unknown' : 'connect', artifacts: [], warnings: [], complete: false,
     };
     const warn = (code, path, message, source) => {
         metadata.warnings.push({ code, path, ...(options.jobPath ? { jobPath: options.jobPath } : {}),
             domain: metadata.domain, message,
             ...(source ? { source: source.scope ?? source.source, hash: (0, crypto_1.createHash)('sha256').update(source.content).digest('hex') } : {}),
-            recovery: `Restore or sync ${path} in its effective source, then refresh the current job instructions. Record this incident and its recovery in bound job evidence.`,
-            resolved: false });
+            recovery: `Restore or sync ${path} in its effective source, then refresh the current job instructions. Record this incident and its recovery in bound job evidence.` });
     };
-    let paths = ['rules/constitution.md'];
-    // Connect has no job/domain selection. Its fixed constitution must not wait
-    // on an unrelated catalog read (or report a catalog failure as missing policy).
+    const paths = options.jobPath ? [...folders_1.GLOBAL_RULE_PATHS] : ['rules/constitution.md'];
     if (options.jobPath) {
-        try {
-            const resolved = await withRuleDeliveryTimeout(options.resolveFile('domains.json'), timeoutMs);
-            const value = JSON.parse(resolved.content);
-            if (!value || typeof value !== 'object' || value.schemaVersion !== 2
-                || !value.domains || typeof value.domains !== 'object'
-                || Array.isArray(value.domains))
-                throw new Error('Invalid domain catalog');
-            const catalog = value;
-            metadata.catalogVersion = Number.isInteger(catalog.mapVersion) && catalog.mapVersion >= 3 ? catalog.mapVersion : null;
-            Object.assign(metadata, (0, catalog_1.selectCatalogDomain)(catalog, options.jobPath));
-            if ((0, catalog_1.validateDomainCatalog)(value).length)
-                warn('CATALOG_INVALID', 'domains.json', 'Some domain configuration is invalid; retain the constitution and available safe rule paths.', resolved);
-            for (const warning of resolved.resolutionWarnings ?? [])
-                warn('CATALOG_SOURCE_FALLBACK', 'domains.json', warning, resolved);
-            for (const domain of new Set(options.jobPath ? ['global', ...(metadata.domain ? [metadata.domain] : [])] : [])) {
-                const rules = catalog.domains[domain]?.rules;
-                if (Array.isArray(rules))
-                    paths.push(...rules.filter(path => (0, catalog_1.isSafeRegistryPath)(path, 'rules')));
-            }
-            if (metadata.selection === 'unknown')
-                warn('DOMAIN_UNKNOWN', 'domains.json', 'The job folder has no configured domain; configure rules for that folder in domains.json.');
-        }
-        catch (error) {
-            warn(error instanceof RuleFetchTimeout ? 'CATALOG_FETCH_TIMEOUT' : 'CATALOG_UNAVAILABLE', 'domains.json', 'The effective domain catalog is unavailable or invalid; independently load the constitution.');
+        if (metadata.domain) {
+            metadata.selection = 'mapped';
+            paths.push((0, folders_1.domainRulePath)(metadata.domain));
         }
+        else
+            warn('DOMAIN_UNKNOWN', options.jobPath, 'The job must live in a domain folder.');
     }
-    const resolveRule = async (path, ancestors = [], rootPath = path, deadline = Date.now() + timeoutMs) => {
-        if (!(0, catalog_1.isSafeRegistryPath)(path, 'rules') || ancestors.includes(path) || ancestors.length >= 10)
-            throw new RuleSourceFault(path);
-        let resolved;
-        try {
-            resolved = await withRuleDeliveryTimeout(options.resolveFile(path), Math.max(1, deadline - Date.now()));
-        }
-        catch (error) {
-            if (error instanceof RuleFetchTimeout)
-                throw error;
-            throw new RuleSourceFault(path);
-        }
-        if (!resolved.content.trim())
-            throw new RuleSourceFault(path, resolved);
-        if (resolved.content.includes('\u0000') || resolved.content.includes('\ufffd'))
-            throw new RuleSourceFault(path, resolved);
-        const frontmatter = resolved.content.match(/^---\r?\n([\s\S]+?)\r?\n---/);
-        if (frontmatter?.[1].trim().startsWith('{')) {
-            try {
-                JSON.parse(frontmatter[1]);
-            }
-            catch {
-                throw new RuleSourceFault(path, resolved);
-            }
-        }
-        if (new inheritance_parser_1.InheritanceParser().parse(resolved.content).hasImports)
-            throw new RuleSourceFault(path, resolved);
-        const includes = [...resolved.content.matchAll(/\{\{\s*include:\s*([^}]+)\}\}/g)];
-        // Reject malformed directives before traversing or certifying this source's
-        // children. Its caller can then retain valid sibling fragments independently.
-        const literalContent = resolved.content.replace(/\{\{\s*include:\s*([^}]+)\}\}/g, '');
-        if (includes.some(match => !match[1].trim()) || /\{\{\s*(?:include|import)\s*:/.test(literalContent)) {
-            throw new RuleSourceFault(path, resolved);
-        }
-        if (!includes.length)
-            return resolved;
-        const expanded = await Promise.all(includes.map(async (match) => {
-            const childPath = match[1].trim();
-            try {
-                const child = await resolveRule(childPath, [...ancestors, path], rootPath, deadline);
-                (metadata.includedArtifacts ??= []).push({ path: childPath, source: child.source,
-                    ...(child.scope ? { scope: child.scope } : {}), inherited: child.inherited,
-                    hash: (0, crypto_1.createHash)('sha256').update(child.content).digest('hex') });
-                for (const warning of child.resolutionWarnings ?? []) {
-                    warn('RULE_SOURCE_FALLBACK', childPath, warning, child);
-                    metadata.warnings[metadata.warnings.length - 1].affectedPath = rootPath;
+    const results = await Promise.all([...new Set(paths)].map(async (rootPath) => {
+        const sources = new Map();
+        const deadline = Date.now() + timeoutMs;
+        const reader = {
+            getJob: async () => null,
+            listItems: async () => [],
+            getFile: async (path) => {
+                if (!(0, folders_1.isSafeRegistryPath)(path, 'rules'))
+                    throw new RuleSourceFault(path);
+                let resolved;
+                try {
+                    resolved = await withRuleDeliveryTimeout(options.resolveFile(path), Math.max(1, deadline - Date.now()));
+                }
+                catch (error) {
+                    if (error instanceof RuleFetchTimeout)
+                        throw error;
+                    throw new RuleSourceFault(path);
+                }
+                sources.set(path, resolved);
+                const content = resolved.content;
+                if (!content.trim() || content.includes('\u0000') || content.includes('\ufffd'))
+                    throw new RuleSourceFault(path, resolved);
+                const frontmatter = content.match(/^---\r?\n([\s\S]+?)\r?\n---/);
+                if (frontmatter?.[1].trim().startsWith('{')) {
+                    try {
+                        JSON.parse(frontmatter[1]);
+                    }
+                    catch {
+                        throw new RuleSourceFault(path, resolved);
+                    }
                 }
-                return child.content;
+                const directives = [...content.matchAll(/\{\{\s*include:\s*([^}]+)\}\}/g)];
+                const remaining = content.replace(/\{\{\s*include:\s*([^}]+)\}\}/g, '');
+                if (new inheritance_parser_1.InheritanceParser().parse(content).hasImports || directives.some(match => !match[1].trim()) || /\{\{\s*(?:include|import)\s*:/.test(remaining))
+                    throw new RuleSourceFault(path, resolved);
+                return content;
             }
-            catch (error) {
+        };
+        const content = await (0, include_resolver_1.resolveIncludes)('{{include:' + rootPath + '}}', reader, undefined, undefined, {
+            onResolved: (path, content) => {
+                const source = sources.get(path);
+                if (!content.trim())
+                    throw new RuleSourceFault(path, source);
+                const artifact = { path, source: source.source, ...(source.scope ? { scope: source.scope } : {}), inherited: source.inherited,
+                    hash: (0, crypto_1.createHash)('sha256').update(content).digest('hex') };
+                if (path === rootPath)
+                    metadata.artifacts.push(artifact);
+                else
+                    (metadata.includedArtifacts ??= []).push(artifact);
+                for (const warning of source.resolutionWarnings ?? []) {
+                    warn('RULE_SOURCE_FALLBACK', path, warning, source);
+                    if (path !== rootPath)
+                        metadata.warnings[metadata.warnings.length - 1].affectedPath = rootPath;
+                }
+            },
+            onError: (path, error) => {
                 const fault = error instanceof RuleSourceFault ? error : undefined;
-                warn(error instanceof RuleFetchTimeout ? 'RULE_FETCH_TIMEOUT' : 'RULE_UNAVAILABLE', fault?.path ?? childPath, 'Included rule source is missing, empty, invalid, cyclic or unavailable; available sibling guidance remains in force.', fault?.resolved);
-                metadata.warnings[metadata.warnings.length - 1].affectedPath = rootPath;
+                warn(error instanceof RuleFetchTimeout ? 'RULE_FETCH_TIMEOUT' : 'RULE_UNAVAILABLE', fault?.path ?? path, 'Rule source is missing, empty, invalid, cyclic or unavailable; other available rules remain in force.', fault?.resolved);
+                if (path !== rootPath)
+                    metadata.warnings[metadata.warnings.length - 1].affectedPath = rootPath;
                 return '';
             }
-        }));
-        let index = 0;
-        const content = resolved.content.replace(/\{\{\s*include:\s*([^}]+)\}\}/g, () => expanded[index++]);
-        if (!content.trim())
-            throw new RuleSourceFault(path, resolved);
-        return { ...resolved, content };
-    };
-    const results = await Promise.all([...new Set(paths)].map(async (path) => {
-        let resolved;
-        try {
-            resolved = await resolveRule(path);
-            if (/\{\{\s*(?:include|import)\s*:/.test(resolved.content)) {
-                throw new Error('Unresolved rule source');
-            }
-            return { path, resolved };
-        }
-        catch (error) {
-            return { path, error, resolved };
-        }
+        });
+        return { path: rootPath, content };
     }));
     const bodies = [];
-    for (const result of results) {
-        if ('error' in result) {
-            const fault = result.error instanceof RuleSourceFault ? result.error : undefined;
-            warn(result.error instanceof RuleFetchTimeout ? 'RULE_FETCH_TIMEOUT' : 'RULE_UNAVAILABLE', fault?.path ?? result.path, 'Rule source is missing, empty, invalid, cyclic or unavailable; other available rules remain in force.', fault?.resolved ?? result.resolved);
-            if (fault && fault.path !== result.path)
-                metadata.warnings[metadata.warnings.length - 1].affectedPath = result.path;
-            continue;
-        }
-        const resolved = result.resolved;
-        metadata.artifacts.push({ path: result.path, source: resolved.source, ...(resolved.scope ? { scope: resolved.scope } : {}),
-            inherited: resolved.inherited, hash: (0, crypto_1.createHash)('sha256').update(resolved.content).digest('hex') });
-        for (const warning of resolved.resolutionWarnings ?? [])
-            warn('RULE_SOURCE_FALLBACK', result.path, warning, resolved);
-        bodies.push(`### ${result.path}\n\n${resolved.content}`);
-    }
+    for (const result of results)
+        if (result.content.trim())
+            bodies.push(`### ${result.path}\n\n${result.content}`);
+    // Keep the global/domain order stable even when independent reads finish out of order.
+    metadata.artifacts.sort((a, b) => paths.indexOf(a.path) - paths.indexOf(b.path));
     metadata.complete = metadata.warnings.length === 0;
     const warnings = metadata.warnings.map(warning => `- ${warning.code}: ${warning.message} ${warning.recovery}`);
     return { text: ['## Applicable rules', ...bodies, ...(warnings.length ? ['### Rule delivery warnings', ...warnings] : [])].join('\n\n'), metadata };
 }
-/** Replace only the advertised rule block; keep phase content and warning history. */
-function attachRuleAssembly(response, assembly) {
-    const content = [...(response.content ?? [])];
-    const previous = response.structuredContent?.ruleAssembly;
-    const warnings = [...assembly.metadata.warnings];
-    const incidentKey = (warning) => `${warning.code}:${warning.path}:${warning.hash ?? ''}`;
-    const priorWarnings = Array.isArray(previous?.warnings) ? previous.warnings : [];
-    const validWarning = (warning) => !!warning && typeof warning === 'object'
-        && ['code', 'path', 'message', 'recovery'].every(key => typeof warning[key] === 'string')
-        && typeof warning.resolved === 'boolean';
-    if (previous && (!Array.isArray(previous.warnings) || priorWarnings.some(warning => !validWarning(warning)))) {
-        warnings.push({ code: 'ASSEMBLY_METADATA_INVALID', path: 'ruleAssembly.warnings', domain: assembly.metadata.domain,
-            message: 'Prior rule delivery incident metadata is invalid; available rules remain in force.',
-            recovery: 'Refresh the current instructions and retain the invalid delivery incident in bound job evidence.', resolved: false });
-    }
-    for (const prior of priorWarnings.filter(validWarning)) {
-        if (warnings.some(warning => incidentKey(warning) === incidentKey(prior)))
-            continue;
-        const recovered = prior.path === 'domains.json'
-            ? assembly.metadata.catalogVersion !== null && assembly.metadata.selection !== 'unknown'
-                && !assembly.metadata.warnings.some(warning => warning.path === prior.path)
-            : (prior.affectedPath
-                ? assembly.metadata.artifacts.some(artifact => artifact.path === prior.affectedPath)
-                    && (assembly.metadata.includedArtifacts ?? []).some(artifact => artifact.path === prior.path)
-                : assembly.metadata.artifacts.some(artifact => artifact.path === prior.path))
-                && !assembly.metadata.warnings.some(warning => warning.path === prior.path);
-        warnings.push({ ...prior, resolved: prior.resolved || recovered });
-    }
-    const previousIndex = previous?.contentBlockIndex;
-    const index = Number.isInteger(previousIndex) && previousIndex >= 0 && previousIndex < content.length ? previousIndex : content.length;
-    const retained = warnings.filter(warning => !assembly.metadata.warnings.includes(warning));
-    const history = retained.length ? '\n\n### Prior rule delivery incidents\n' + retained.map(warning => `- ${warning.code} (${warning.resolved ? 'recovered' : 'unresolved'}): ${warning.path}. ${warning.recovery}`).join('\n') : '';
-    content[index] = { type: 'text', text: assembly.text + history };
-    return { ...response, content, structuredContent: { ...response.structuredContent,
-            ruleAssembly: { ...assembly.metadata, warnings,
-                complete: assembly.metadata.complete && warnings.every(warning => warning.resolved),
-                contentBlockIndex: index } } };
+/** Deliver instructions as text; assembly diagnostics stay with the caller. */
+function appendRuleInstructions(response, assembly) {
+    return { ...response, content: [...(response.content ?? []), { type: 'text', text: assembly.text }] };
 }

package/dist/src/core/utils/include-resolver.js

@@ -46,60 +46,38 @@ function resolveIncludesWithIndex(content, fileIndex) {
     }
     return result;
 }
-/**
- * Asynchronously resolve {{include:path}} directives in content using a RegistryResolver.
- *
- * @param content - Raw content that may contain {{include:path}} directives
- * @param resolver - RegistryResolver instance
- * @param basePath - Path of the current file, used to resolve relative ./ includes
- * @param dedup - Optional session-level dedup hook (issue #801)
- * @returns Content with all resolvable includes inlined
- */
-async function resolveIncludes(content, resolver, basePath, dedup) {
-    let result = content;
-    let pass = 0;
-    while (result.includes('{{include:') && pass < exports.MAX_INCLUDE_PASSES) {
-        // Collect all unique includes in this pass
-        const matches = result.match(/\{\{include:([^}]+)\}\}/g);
-        if (!matches)
-            break;
-        const uniqueMatches = Array.from(new Set(matches));
-        for (const match of uniqueMatches) {
-            const filePath = match.match(/\{\{include:([^}]+)\}\}/)[1].trim();
-            let targetPath = filePath;
-            if (filePath.startsWith('./') && basePath) {
-                // Resolve relative to the directory of the current file
-                const dir = basePath.includes('/') ? basePath.substring(0, basePath.lastIndexOf('/')) : '';
-                targetPath = dir ? `${dir}/${filePath.substring(2)}` : filePath.substring(2);
-            }
-            // Session-level dedup (issue #801): if this target's full content was
-            // already emitted earlier in the session, substitute a backreference
-            // rather than fetching and inlining it again.
-            if (dedup && dedup.isAlreadyEmitted(targetPath)) {
+async function resolveIncludes(content, resolver, basePath, dedup, options = {}) {
+    const expand = async (body, base, ancestors) => {
+        const pattern = /\{\{\s*include:\s*([^}]+)\}\}/g;
+        const matches = [...new Set(body.match(pattern) ?? [])];
+        let result = body;
+        for (const match of matches) {
+            const filePath = match.match(/\{\{\s*include:\s*([^}]+)\}\}/)[1].trim();
+            const dir = base?.includes('/') ? base.substring(0, base.lastIndexOf('/')) : '';
+            const targetPath = filePath.startsWith('./') ? (dir ? dir + '/' : '') + filePath.substring(2) : filePath;
+            if (dedup?.isAlreadyEmitted(targetPath)) {
                 result = result.split(match).join(dedup.backreference(targetPath));
                 continue;
             }
             try {
+                if (ancestors.includes(targetPath) || ancestors.length >= exports.MAX_INCLUDE_PASSES)
+                    throw new Error('Cyclic include or maximum include depth exceeded');
                 const fileContent = await resolver.getFile(targetPath);
-                if (fileContent !== null) {
-                    // Recursively resolve includes in the newly fetched content
-                    const resolvedContent = await resolveIncludes(fileContent, resolver, targetPath, dedup);
-                    // Replace all occurrences of this specific include
-                    result = result.split(match).join(resolvedContent);
-                    // Mark as emitted only after a successful full inline, so a failed
-                    // fetch never causes a later occurrence to be silently backreferenced.
-                    if (dedup)
-                        dedup.recordEmitted(targetPath);
-                }
-                else {
-                    console.warn(`⚠️ Include file not found via resolver: ${targetPath} (original: ${filePath}, base: ${basePath})`);
-                }
+                if (fileContent === null)
+                    throw new Error('Include file unavailable: ' + targetPath);
+                const resolvedContent = await expand(fileContent, targetPath, [...ancestors, targetPath]);
+                options.onResolved?.(targetPath, resolvedContent);
+                result = result.split(match).join(resolvedContent);
+                dedup?.recordEmitted(targetPath);
             }
             catch (error) {
-                console.error(`❌ Failed to resolve include via resolver: ${targetPath}`, error);
+                if (options.onError)
+                    result = result.split(match).join(options.onError(targetPath, error));
+                else
+                    console.warn('Failed to resolve include ' + targetPath + ': ' + String(error));
             }
         }
-        pass++;
-    }
-    return result;
+        return result;
+    };
+    return expand(content, basePath, basePath ? [basePath] : []);
 }

package/dist/src/core/utils/local-registry-resolver.js

@@ -46,7 +46,6 @@ const path_1 = require("path");
 const inheritance_parser_1 = require("./inheritance-parser");
 const job_parser_1 = require("./job-parser");
 const project_fraim_paths_1 = require("./project-fraim-paths");
-const catalog_1 = require("../../../registry/scripts/domains/catalog");
 class LocalRegistryResolver {
     constructor(options) {
         this.workspaceRoot = options.workspaceRoot;
@@ -201,13 +200,6 @@ class LocalRegistryResolver {
         const normalizedPath = path.replace(/\\/g, '/').replace(/^\/+/, '');
         const parts = normalizedPath.split('/');
         const type = parts[0];
-        if (normalizedPath === 'domains.json') {
-            if (this.effectiveFraimDir)
-                return (0, path_1.join)(this.effectiveFraimDir, 'domains.json');
-            const machineCatalog = (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'domains.json');
-            this.onLocalDependency?.(machineCatalog, 'file');
-            return (0, fs_1.existsSync)(machineCatalog) ? machineCatalog : this.getFraimPath('domains.json');
-        }
         if (type === 'jobs' || type === 'workflows') {
             if (parts.length >= 3 && (parts[1] === 'ai-employee' || parts[1] === 'ai-manager')) {
                 return (0, path_1.join)(this.getSyncedCatalogRoot(parts[1], type), ...parts.slice(2));
@@ -546,47 +538,6 @@ class LocalRegistryResolver {
      * @param path - Registry path (e.g., "workflows/product-building/spec.md")
      * @returns Resolved file with metadata
      */
-    async resolveDomainCatalog() {
-        const path = 'domains.json';
-        const localBaseline = this.readSyncedLocalFile(path) ?? this.readWorkspaceRegistryFile(path);
-        let content = localBaseline ?? await this.fetchRemoteWithFallback(path);
-        let source = localBaseline === null ? 'remote' : 'local';
-        let scope;
-        let catalog = JSON.parse(content);
-        const resolutionWarnings = [];
-        let projectContent = null;
-        if (this.hasLocalOverride(path)) {
-            try {
-                const candidate = this.readLocalOverride(path);
-                if (!this.shouldFilter || !this.shouldFilter(candidate))
-                    projectContent = candidate;
-            }
-            catch {
-                resolutionWarnings.push('Project domain configuration could not be read; available earlier configuration retained.');
-            }
-        }
-        const layers = [
-            { content: this.readOrgOverlayFile(path, resolutionWarnings), scope: 'org' },
-            { content: this.readManagerOverlayFile(path, resolutionWarnings), scope: 'manager' },
-            ...(this.managerLocalRoot !== this.managerCacheRoot ? [{ content: this.readManagerLocalOverlayFile(path, resolutionWarnings), scope: 'manager' }] : []),
-            { content: projectContent, scope: 'project' },
-        ];
-        for (const layer of layers) {
-            if (layer.content === null)
-                continue;
-            try {
-                catalog = (0, catalog_1.mergeDomainCatalog)(catalog, JSON.parse(layer.content));
-            }
-            catch {
-                resolutionWarnings.push('Invalid ' + layer.scope + ' domain configuration; available earlier configuration retained.');
-                continue;
-            }
-            content = JSON.stringify(catalog);
-            source = 'local';
-            scope = layer.scope;
-        }
-        return { content, source, ...(scope ? { scope } : {}), personalized: !!scope, inherited: !!scope, ...(resolutionWarnings.length ? { resolutionWarnings } : {}) };
-    }
     assertDependenciesObserved() {
         if (this.dependencyFailure)
             throw this.dependencyFailure.error;
@@ -606,8 +557,6 @@ class LocalRegistryResolver {
         return warnings.length ? { ...resolved, resolutionWarnings: [...warnings, ...(resolved.resolutionWarnings ?? [])] } : resolved;
     }
     async resolveFileWithWarnings(path, options, applyInheritance, warnings) {
-        if (this.normalizeRegistryPath(path) === 'domains.json')
-            return this.resolveDomainCatalog();
         const includeMetadata = options.includeMetadata ?? true;
         const stripMcpHeader = options.stripMcpHeader ?? false;
         const resolveContent = (content, personalized = true) => applyInheritance