@promptbook/wizard 0.112.0-56 → 0.112.0-58

package/esm/index.es.js

@@ -38,7 +38,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-56';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-58';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -19405,6 +19405,186 @@ function createBasicAgentModelRequirements(agentName) {
 }
 // TODO: [🐤] Deduplicate `AgentModelRequirements` and `ModelRequirements` model requirements
 
+/**
+ * @@@
+ *
+ * @private utility for commitments
+ */
+function formatOptionalInstructionBlock(label, content) {
+    const trimmedContent = spaceTrim$1(content);
+    if (!trimmedContent) {
+        return '';
+    }
+    return spaceTrim$1((block) => `
+        - ${label}:
+            ${block(trimmedContent
+        .split(/\r?\n/)
+        .map((line) => `- ${line}`)
+        .join('\n'))}
+    `);
+}
+
+/**
+ * All `USE` commitment types currently participating in final system-message aggregation.
+ *
+ * @private internal constant for `aggregateUseCommitmentSystemMessages`
+ */
+const AGGREGATED_USE_COMMITMENT_TYPES = [
+    'USE BROWSER',
+    'USE DEEPSEARCH',
+    'USE SEARCH ENGINE',
+    'USE TIME',
+];
+/**
+ * Prefix used for temporary in-system-message placeholders that preserve the first-occurrence position of aggregated `USE` sections.
+ *
+ * @private internal constant for `appendAggregatedUseCommitmentPlaceholder`
+ */
+const AGGREGATED_USE_COMMITMENT_PLACEHOLDER_PREFIX = '# AGGREGATED USE COMMITMENT: ';
+/**
+ * Type guard for `USE` commitment types that are aggregated in the final system message.
+ *
+ * @param type - Commitment type to check.
+ * @returns `true` when the commitment participates in `USE` system-message aggregation.
+ *
+ * @private internal utility of `aggregateUseCommitmentSystemMessages`
+ */
+function isAggregatedUseCommitmentType(type) {
+    return AGGREGATED_USE_COMMITMENT_TYPES.includes(type);
+}
+/**
+ * Creates the placeholder token used to reserve the first-occurrence position of an aggregated `USE` system-message section.
+ *
+ * @param type - Aggregated `USE` commitment type.
+ * @returns Single-line placeholder comment stored in the interim system message.
+ *
+ * @private internal utility of `appendAggregatedUseCommitmentPlaceholder`
+ */
+function getAggregatedUseCommitmentPlaceholder(type) {
+    return `${AGGREGATED_USE_COMMITMENT_PLACEHOLDER_PREFIX}${type}`;
+}
+/**
+ * Combines distinct additional instruction blocks in source order.
+ *
+ * @param additionalInstructions - Deduplicated instruction blocks collected from the agent source.
+ * @returns Combined instruction text ready for `formatOptionalInstructionBlock`.
+ *
+ * @private internal utility of `createAggregatedUseCommitmentSystemMessage`
+ */
+function combineAdditionalInstructions(additionalInstructions) {
+    return additionalInstructions.join('\n');
+}
+/**
+ * Creates the final aggregated system-message section for a supported `USE` commitment type.
+ *
+ * @param type - Aggregated `USE` commitment type.
+ * @param additionalInstructions - Distinct additional instructions in source order.
+ * @returns Final system-message block for the commitment type.
+ *
+ * @private internal utility of `aggregateUseCommitmentSystemMessages`
+ */
+function createAggregatedUseCommitmentSystemMessage(type, additionalInstructions) {
+    const combinedAdditionalInstructions = combineAdditionalInstructions(additionalInstructions);
+    switch (type) {
+        case 'USE TIME':
+            return spaceTrim$1((block) => `
+                    Time and date context:
+                    - It is ${moment().format('MMMM YYYY')} now.
+                    - If you need more precise current time information, use the tool "get_current_time".
+                    ${block(formatOptionalInstructionBlock('Time instructions', combinedAdditionalInstructions))}
+                `);
+        case 'USE BROWSER':
+            return spaceTrim$1((block) => `
+                    You have access to browser tools to fetch and access content from the internet.
+                    - Use "fetch_url_content" to retrieve content from specific URLs (webpages or documents) using scrapers.
+                    - Use "run_browser" for real interactive browser automation (navigation, clicks, typing, waiting, scrolling).
+                    When you need to know information from a specific website or document, use the fetch_url_content tool.
+                    ${block(formatOptionalInstructionBlock('Browser instructions', combinedAdditionalInstructions))}
+                `);
+        case 'USE SEARCH ENGINE':
+            return spaceTrim$1((block) => `
+                    Tool:
+                    - You have access to the web search engine via the tool "web_search".
+                    - Use it to find up-to-date information or facts that you don't know.
+                    - When you need to know some information from the internet, use the tool provided to you.
+                    - Do not make up information when you can search for it.
+                    - Do not tell the user you cannot search for information, YOU CAN.
+                    ${block(formatOptionalInstructionBlock('Search instructions', combinedAdditionalInstructions))}
+                `);
+        case 'USE DEEPSEARCH':
+            return spaceTrim$1((block) => `
+                    Tool:
+                    - You have access to DeepSearch via the tool "deep_search".
+                    - Use it for broader research tasks that need multi-step investigation, comparison, or synthesis across multiple sources.
+                    - Prefer it over quick search when the user asks for a well-grounded brief, report, or deeper investigation.
+                    - Do not pretend you cannot research current information when this tool is available.
+                    ${block(formatOptionalInstructionBlock('DeepSearch instructions', combinedAdditionalInstructions))}
+                `);
+    }
+}
+/**
+ * Adds the placeholder for an aggregated `USE` system-message section only once, preserving the section position from the first occurrence.
+ *
+ * @param requirements - Current model requirements.
+ * @param type - Aggregated `USE` commitment type being applied.
+ * @returns Requirements with the placeholder inserted when it was not already present.
+ *
+ * @private internal utility of `USE` commitments
+ */
+function appendAggregatedUseCommitmentPlaceholder(requirements, type) {
+    const placeholder = getAggregatedUseCommitmentPlaceholder(type);
+    if (requirements.systemMessage.includes(placeholder)) {
+        return requirements;
+    }
+    const systemMessage = requirements.systemMessage.trim()
+        ? `${requirements.systemMessage}\n\n${placeholder}`
+        : placeholder;
+    return {
+        ...requirements,
+        systemMessage,
+    };
+}
+/**
+ * Replaces temporary `USE` placeholders with one aggregated system-message block per commitment type.
+ *
+ * Distinct additional-instruction blocks are merged in stable source order while the hard-coded section is emitted only once.
+ *
+ * @param requirements - Model requirements produced by commitment-by-commitment application.
+ * @param commitments - Filtered commitments in their original source order.
+ * @returns Requirements with aggregated `USE` system-message sections.
+ *
+ * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ */
+function aggregateUseCommitmentSystemMessages(requirements, commitments) {
+    const additionalInstructionsByType = new Map();
+    for (const commitment of commitments) {
+        if (!isAggregatedUseCommitmentType(commitment.type)) {
+            continue;
+        }
+        let additionalInstructions = additionalInstructionsByType.get(commitment.type);
+        if (!additionalInstructions) {
+            additionalInstructions = [];
+            additionalInstructionsByType.set(commitment.type, additionalInstructions);
+        }
+        const normalizedContent = spaceTrim$1(commitment.content);
+        if (normalizedContent && !additionalInstructions.includes(normalizedContent)) {
+            additionalInstructions.push(normalizedContent);
+        }
+    }
+    let systemMessage = requirements.systemMessage;
+    for (const [type, additionalInstructions] of additionalInstructionsByType) {
+        const placeholder = getAggregatedUseCommitmentPlaceholder(type);
+        if (!systemMessage.includes(placeholder)) {
+            continue;
+        }
+        systemMessage = systemMessage.replace(placeholder, createAggregatedUseCommitmentSystemMessage(type, additionalInstructions));
+    }
+    return {
+        ...requirements,
+        systemMessage,
+    };
+}
+
 /**
  * Generates a regex pattern to match a specific commitment
  *
@@ -20723,25 +20903,6 @@ class LanguageCommitmentDefinition extends BaseCommitmentDefinition {
 }
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
-/**
- * @@@
- *
- * @private utility for commitments
- */
-function formatOptionalInstructionBlock(label, content) {
-    const trimmedContent = spaceTrim$1(content);
-    if (!trimmedContent) {
-        return '';
-    }
-    return spaceTrim$1((block) => `
-        - ${label}:
-            ${block(trimmedContent
-        .split(/\r?\n/)
-        .map((line) => `- ${line}`)
-        .join('\n'))}
-    `);
-}
-
 /**
  * Names of tools used by the MEMORY commitment.
  *
@@ -27564,167 +27725,6 @@ class TemplateCommitmentDefinition extends BaseCommitmentDefinition {
 }
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
-/**
- * All `USE` commitment types currently participating in final system-message aggregation.
- *
- * @private internal constant for `aggregateUseCommitmentSystemMessages`
- */
-const AGGREGATED_USE_COMMITMENT_TYPES = [
-    'USE BROWSER',
-    'USE DEEPSEARCH',
-    'USE SEARCH ENGINE',
-    'USE TIME',
-];
-/**
- * Prefix used for temporary in-system-message placeholders that preserve the first-occurrence position of aggregated `USE` sections.
- *
- * @private internal constant for `appendAggregatedUseCommitmentPlaceholder`
- */
-const AGGREGATED_USE_COMMITMENT_PLACEHOLDER_PREFIX = '# AGGREGATED USE COMMITMENT: ';
-/**
- * Type guard for `USE` commitment types that are aggregated in the final system message.
- *
- * @param type - Commitment type to check.
- * @returns `true` when the commitment participates in `USE` system-message aggregation.
- *
- * @private internal utility of `aggregateUseCommitmentSystemMessages`
- */
-function isAggregatedUseCommitmentType(type) {
-    return AGGREGATED_USE_COMMITMENT_TYPES.includes(type);
-}
-/**
- * Creates the placeholder token used to reserve the first-occurrence position of an aggregated `USE` system-message section.
- *
- * @param type - Aggregated `USE` commitment type.
- * @returns Single-line placeholder comment stored in the interim system message.
- *
- * @private internal utility of `appendAggregatedUseCommitmentPlaceholder`
- */
-function getAggregatedUseCommitmentPlaceholder(type) {
-    return `${AGGREGATED_USE_COMMITMENT_PLACEHOLDER_PREFIX}${type}`;
-}
-/**
- * Combines distinct additional instruction blocks in source order.
- *
- * @param additionalInstructions - Deduplicated instruction blocks collected from the agent source.
- * @returns Combined instruction text ready for `formatOptionalInstructionBlock`.
- *
- * @private internal utility of `createAggregatedUseCommitmentSystemMessage`
- */
-function combineAdditionalInstructions(additionalInstructions) {
-    return additionalInstructions.join('\n');
-}
-/**
- * Creates the final aggregated system-message section for a supported `USE` commitment type.
- *
- * @param type - Aggregated `USE` commitment type.
- * @param additionalInstructions - Distinct additional instructions in source order.
- * @returns Final system-message block for the commitment type.
- *
- * @private internal utility of `aggregateUseCommitmentSystemMessages`
- */
-function createAggregatedUseCommitmentSystemMessage(type, additionalInstructions) {
-    const combinedAdditionalInstructions = combineAdditionalInstructions(additionalInstructions);
-    switch (type) {
-        case 'USE TIME':
-            return spaceTrim$1((block) => `
-                    Time and date context:
-                    - It is ${moment().format('MMMM YYYY')} now.
-                    - If you need more precise current time information, use the tool "get_current_time".
-                    ${block(formatOptionalInstructionBlock('Time instructions', combinedAdditionalInstructions))}
-                `);
-        case 'USE BROWSER':
-            return spaceTrim$1((block) => `
-                    You have access to browser tools to fetch and access content from the internet.
-                    - Use "fetch_url_content" to retrieve content from specific URLs (webpages or documents) using scrapers.
-                    - Use "run_browser" for real interactive browser automation (navigation, clicks, typing, waiting, scrolling).
-                    When you need to know information from a specific website or document, use the fetch_url_content tool.
-                    ${block(formatOptionalInstructionBlock('Browser instructions', combinedAdditionalInstructions))}
-                `);
-        case 'USE SEARCH ENGINE':
-            return spaceTrim$1((block) => `
-                    Tool:
-                    - You have access to the web search engine via the tool "web_search".
-                    - Use it to find up-to-date information or facts that you don't know.
-                    - When you need to know some information from the internet, use the tool provided to you.
-                    - Do not make up information when you can search for it.
-                    - Do not tell the user you cannot search for information, YOU CAN.
-                    ${block(formatOptionalInstructionBlock('Search instructions', combinedAdditionalInstructions))}
-                `);
-        case 'USE DEEPSEARCH':
-            return spaceTrim$1((block) => `
-                    Tool:
-                    - You have access to DeepSearch via the tool "deep_search".
-                    - Use it for broader research tasks that need multi-step investigation, comparison, or synthesis across multiple sources.
-                    - Prefer it over quick search when the user asks for a well-grounded brief, report, or deeper investigation.
-                    - Do not pretend you cannot research current information when this tool is available.
-                    ${block(formatOptionalInstructionBlock('DeepSearch instructions', combinedAdditionalInstructions))}
-                `);
-    }
-}
-/**
- * Adds the placeholder for an aggregated `USE` system-message section only once, preserving the section position from the first occurrence.
- *
- * @param requirements - Current model requirements.
- * @param type - Aggregated `USE` commitment type being applied.
- * @returns Requirements with the placeholder inserted when it was not already present.
- *
- * @private internal utility of `USE` commitments
- */
-function appendAggregatedUseCommitmentPlaceholder(requirements, type) {
-    const placeholder = getAggregatedUseCommitmentPlaceholder(type);
-    if (requirements.systemMessage.includes(placeholder)) {
-        return requirements;
-    }
-    const systemMessage = requirements.systemMessage.trim()
-        ? `${requirements.systemMessage}\n\n${placeholder}`
-        : placeholder;
-    return {
-        ...requirements,
-        systemMessage,
-    };
-}
-/**
- * Replaces temporary `USE` placeholders with one aggregated system-message block per commitment type.
- *
- * Distinct additional-instruction blocks are merged in stable source order while the hard-coded section is emitted only once.
- *
- * @param requirements - Model requirements produced by commitment-by-commitment application.
- * @param commitments - Filtered commitments in their original source order.
- * @returns Requirements with aggregated `USE` system-message sections.
- *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
- */
-function aggregateUseCommitmentSystemMessages(requirements, commitments) {
-    const additionalInstructionsByType = new Map();
-    for (const commitment of commitments) {
-        if (!isAggregatedUseCommitmentType(commitment.type)) {
-            continue;
-        }
-        let additionalInstructions = additionalInstructionsByType.get(commitment.type);
-        if (!additionalInstructions) {
-            additionalInstructions = [];
-            additionalInstructionsByType.set(commitment.type, additionalInstructions);
-        }
-        const normalizedContent = spaceTrim$1(commitment.content);
-        if (normalizedContent && !additionalInstructions.includes(normalizedContent)) {
-            additionalInstructions.push(normalizedContent);
-        }
-    }
-    let systemMessage = requirements.systemMessage;
-    for (const [type, additionalInstructions] of additionalInstructionsByType) {
-        const placeholder = getAggregatedUseCommitmentPlaceholder(type);
-        if (!systemMessage.includes(placeholder)) {
-            continue;
-        }
-        systemMessage = systemMessage.replace(placeholder, createAggregatedUseCommitmentSystemMessage(type, additionalInstructions));
-    }
-    return {
-        ...requirements,
-        systemMessage,
-    };
-}
-
 /**
  * Client-side safe wrapper for fetching URL content
  *
@@ -28768,6 +28768,44 @@ function mapGoogleCalendarEvent(event) {
  * @private constant of createUseCalendarTools
  */
 const CALENDAR_URL_PARAMETER_DESCRIPTION = 'Google Calendar URL configured by USE CALENDAR (for example "https://calendar.google.com/...").';
+/**
+ * Shared schema for string arrays used by USE CALENDAR tools.
+ *
+ * @private constant of createUseCalendarTools
+ */
+const STRING_ARRAY_ITEMS_SCHEMA = {
+    type: 'string',
+};
+/**
+ * Shared schema for integer arrays used by USE CALENDAR tools.
+ *
+ * @private constant of createUseCalendarTools
+ */
+const INTEGER_ARRAY_ITEMS_SCHEMA = {
+    type: 'integer',
+};
+/**
+ * Shared `sendUpdates` schema used by USE CALENDAR tools.
+ *
+ * @private constant of createUseCalendarTools
+ */
+const SEND_UPDATES_PARAMETER_SCHEMA = {
+    type: 'string',
+    description: 'Guest update policy ("all", "externalOnly", "none").',
+    enum: ['all', 'externalOnly', 'none'],
+};
+/**
+ * Creates an array parameter schema with explicit item definition so OpenAI accepts it.
+ *
+ * @private function of createUseCalendarTools
+ */
+function createArrayParameterSchema(description, items) {
+    return {
+        type: 'array',
+        description,
+        items,
+    };
+}
 /**
  * Adds USE CALENDAR tool definitions while keeping already registered tools untouched.
  *
@@ -28874,18 +28912,9 @@ function createUseCalendarTools(existingTools) {
                     type: 'string',
                     description: 'Optional timezone for datetime values.',
                 },
-                attendees: {
-                    type: 'array',
-                    description: 'Optional guest email list.',
-                },
-                reminderMinutes: {
-                    type: 'array',
-                    description: 'Optional popup reminder minute offsets.',
-                },
-                sendUpdates: {
-                    type: 'string',
-                    description: 'Guest update policy ("all", "externalOnly", "none").',
-                },
+                attendees: createArrayParameterSchema('Optional guest email list.', STRING_ARRAY_ITEMS_SCHEMA),
+                reminderMinutes: createArrayParameterSchema('Optional popup reminder minute offsets.', INTEGER_ARRAY_ITEMS_SCHEMA),
+                sendUpdates: SEND_UPDATES_PARAMETER_SCHEMA,
             },
             required: ['summary', 'start', 'end'],
         },
@@ -28928,18 +28957,9 @@ function createUseCalendarTools(existingTools) {
                     type: 'string',
                     description: 'Optional timezone for datetime values.',
                 },
-                attendees: {
-                    type: 'array',
-                    description: 'Optional replacement guest email list.',
-                },
-                reminderMinutes: {
-                    type: 'array',
-                    description: 'Optional replacement popup reminder minute offsets.',
-                },
-                sendUpdates: {
-                    type: 'string',
-                    description: 'Guest update policy ("all", "externalOnly", "none").',
-                },
+                attendees: createArrayParameterSchema('Optional replacement guest email list.', STRING_ARRAY_ITEMS_SCHEMA),
+                reminderMinutes: createArrayParameterSchema('Optional replacement popup reminder minute offsets.', INTEGER_ARRAY_ITEMS_SCHEMA),
+                sendUpdates: SEND_UPDATES_PARAMETER_SCHEMA,
             },
             required: ['eventId'],
         },
@@ -28958,10 +28978,7 @@ function createUseCalendarTools(existingTools) {
                     type: 'string',
                     description: 'Google Calendar event id.',
                 },
-                sendUpdates: {
-                    type: 'string',
-                    description: 'Guest update policy ("all", "externalOnly", "none").',
-                },
+                sendUpdates: SEND_UPDATES_PARAMETER_SCHEMA,
             },
             required: ['eventId'],
         },
@@ -28980,14 +28997,8 @@ function createUseCalendarTools(existingTools) {
                     type: 'string',
                     description: 'Google Calendar event id.',
                 },
-                guests: {
-                    type: 'array',
-                    description: 'Guest email list to add to the event.',
-                },
-                sendUpdates: {
-                    type: 'string',
-                    description: 'Guest update policy ("all", "externalOnly", "none").',
-                },
+                guests: createArrayParameterSchema('Guest email list to add to the event.', STRING_ARRAY_ITEMS_SCHEMA),
+                sendUpdates: SEND_UPDATES_PARAMETER_SCHEMA,
             },
             required: ['eventId', 'guests'],
         },
@@ -33575,6 +33586,176 @@ function getCommitmentDefinition(type) {
     return COMMITMENT_REGISTRY.find((commitmentDefinition) => commitmentDefinition.type === type) || null;
 }
 
+/**
+ * Commitment types whose content may contain compact agent references that must be resolved before applying the commitment.
+ *
+ * @private internal constant of `applyCommitmentsToAgentModelRequirements`
+ */
+const COMMITMENTS_WITH_AGENT_REFERENCES = new Set(['FROM', 'IMPORT', 'IMPORTS', 'TEAM']);
+/**
+ * Applies parsed commitments one by one while keeping the per-commitment steps focused and easy to follow.
+ *
+ * @param requirements - Current requirements snapshot.
+ * @param commitments - Commitments already filtered for DELETE-like invalidations.
+ * @param options - Optional reference and teammate resolvers.
+ * @returns Requirements after all applicable commitments are processed.
+ *
+ * @private function of `createAgentModelRequirementsWithCommitments`
+ */
+async function applyCommitmentsToAgentModelRequirements(requirements, commitments, options) {
+    for (const [index, commitment] of commitments.entries()) {
+        if (shouldSkipCommitmentApplication(commitment, index, commitments.length)) {
+            continue;
+        }
+        const commitmentContent = await resolveCommitmentContent(commitment, options === null || options === void 0 ? void 0 : options.agentReferenceResolver);
+        requirements = await preResolveTeammateProfilesForTeamCommitment(requirements, commitment, commitmentContent, options);
+        requirements = applyCommitmentDefinitionSafely(requirements, commitment, commitmentContent);
+    }
+    return requirements;
+}
+/**
+ * Resolves compact agent references for commitment types that support them.
+ *
+ * @param commitment - Commitment currently being applied.
+ * @param agentReferenceResolver - Optional resolver for compact agent references.
+ * @returns Original or resolved commitment content.
+ *
+ * @private internal utility of `applyCommitmentsToAgentModelRequirements`
+ */
+async function resolveCommitmentContent(commitment, agentReferenceResolver) {
+    if (!agentReferenceResolver || !isAgentReferenceCommitment(commitment.type)) {
+        return commitment.content;
+    }
+    try {
+        return await agentReferenceResolver.resolveCommitmentContent(commitment.type, commitment.content);
+    }
+    catch (error) {
+        console.warn(`Failed to resolve commitment references for ${commitment.type}, falling back to safe defaults:`, error);
+        return getSafeReferenceCommitmentFallback(commitment.type, commitment.content);
+    }
+}
+/**
+ * Returns a safe fallback content when a resolver fails to transform a reference commitment.
+ *
+ * @param commitmentType - Commitment being resolved.
+ * @param originalContent - Original unresolved commitment content.
+ * @returns Fallback content that keeps requirement creation resilient.
+ *
+ * @private internal utility of `applyCommitmentsToAgentModelRequirements`
+ */
+function getSafeReferenceCommitmentFallback(commitmentType, originalContent) {
+    if (commitmentType === 'FROM') {
+        return 'VOID';
+    }
+    if (commitmentType === 'IMPORT' || commitmentType === 'IMPORTS' || commitmentType === 'TEAM') {
+        return '';
+    }
+    return originalContent;
+}
+/**
+ * Checks whether the commitment content may need agent-reference resolution before application.
+ *
+ * @param commitmentType - Commitment type to check.
+ * @returns `true` when the commitment can contain compact agent references.
+ *
+ * @private internal utility of `resolveCommitmentContent`
+ */
+function isAgentReferenceCommitment(commitmentType) {
+    return COMMITMENTS_WITH_AGENT_REFERENCES.has(commitmentType);
+}
+/**
+ * Determines whether a commitment should be skipped before resolution or application.
+ *
+ * @param commitment - Commitment under consideration.
+ * @param commitmentIndex - Zero-based position among filtered commitments.
+ * @param commitmentCount - Total number of filtered commitments.
+ * @returns `true` when the commitment should not be applied.
+ *
+ * @private internal utility of `applyCommitmentsToAgentModelRequirements`
+ */
+function shouldSkipCommitmentApplication(commitment, commitmentIndex, commitmentCount) {
+    return commitment.type === 'CLOSED' && commitmentIndex !== commitmentCount - 1;
+}
+/**
+ * Pre-resolves teammate profiles for TEAM commitments so the TEAM commitment definition can reuse richer metadata.
+ *
+ * @param requirements - Current requirements snapshot.
+ * @param commitment - Commitment currently being prepared.
+ * @param commitmentContent - Already resolved TEAM commitment content.
+ * @param options - Optional teammate profile resolvers.
+ * @returns Requirements with pre-resolved teammate profiles stored in metadata when possible.
+ *
+ * @private internal utility of `applyCommitmentsToAgentModelRequirements`
+ */
+async function preResolveTeammateProfilesForTeamCommitment(requirements, commitment, commitmentContent, options) {
+    var _a;
+    const profileResolver = (_a = options === null || options === void 0 ? void 0 : options.teammateProfileResolver) !== null && _a !== void 0 ? _a : options === null || options === void 0 ? void 0 : options.agentReferenceResolver;
+    if (commitment.type !== 'TEAM' || !(profileResolver === null || profileResolver === void 0 ? void 0 : profileResolver.resolveTeammateProfile)) {
+        return requirements;
+    }
+    try {
+        const parsedTeammates = parseTeamCommitmentContent(commitmentContent, { strict: false });
+        const preResolvedTeammateProfiles = clonePreResolvedTeammateProfiles(requirements._metadata);
+        for (const teammate of parsedTeammates) {
+            if (preResolvedTeammateProfiles[teammate.url]) {
+                continue;
+            }
+            const profile = await profileResolver.resolveTeammateProfile(teammate.url);
+            if (profile) {
+                preResolvedTeammateProfiles[teammate.url] = profile;
+            }
+        }
+        return {
+            ...requirements,
+            _metadata: {
+                ...requirements._metadata,
+                preResolvedTeammateProfiles,
+            },
+        };
+    }
+    catch (error) {
+        console.warn('Failed to pre-resolve teammate profiles for TEAM commitment:', error);
+        return requirements;
+    }
+}
+/**
+ * Clones the metadata bucket used to cache teammate profiles resolved ahead of TEAM commitment application.
+ *
+ * @param metadata - Current requirements metadata.
+ * @returns Mutable copy of the cached teammate profile map.
+ *
+ * @private internal utility of `preResolveTeammateProfilesForTeamCommitment`
+ */
+function clonePreResolvedTeammateProfiles(metadata) {
+    var _a;
+    return {
+        ...((_a = metadata === null || metadata === void 0 ? void 0 : metadata.preResolvedTeammateProfiles) !== null && _a !== void 0 ? _a : {}),
+    };
+}
+/**
+ * Applies the registered commitment definition while isolating the failure handling from the main loop.
+ *
+ * @param requirements - Current requirements snapshot.
+ * @param commitment - Commitment whose definition should be applied.
+ * @param commitmentContent - Final content passed into the definition.
+ * @returns Updated requirements, or the original requirements when the commitment fails.
+ *
+ * @private internal utility of `applyCommitmentsToAgentModelRequirements`
+ */
+function applyCommitmentDefinitionSafely(requirements, commitment, commitmentContent) {
+    const definition = getCommitmentDefinition(commitment.type);
+    if (!definition) {
+        return requirements;
+    }
+    try {
+        return definition.applyToAgentModelRequirements(requirements, commitmentContent);
+    }
+    catch (error) {
+        console.warn(`Failed to apply commitment ${commitment.type}:`, error);
+        return requirements;
+    }
+}
+
 /**
  * Consumes the agent-name prelude from raw source.
  *
@@ -33842,6 +34023,285 @@ const $fileImportPlugins = [
     TextFileImportPlugin,
 ];
 
+/**
+ * Regex pattern matching markdown horizontal lines that should not be copied into the final system message.
+ *
+ * @private internal constant of `augmentAgentModelRequirementsFromSource`
+ */
+const HORIZONTAL_LINE_PATTERN = /^[\s]*[-_*][\s]*[-_*][\s]*[-_*][\s]*[-_*]*[\s]*$/;
+/**
+ * MIME type prefixes treated as binary and therefore not eligible for text import plugins.
+ *
+ * @private internal constant of `augmentAgentModelRequirementsFromSource`
+ */
+const BINARY_MIME_TYPE_PREFIXES = [
+    'image/',
+    'video/',
+    'audio/',
+    'application/octet-stream',
+    'application/pdf',
+    'application/zip',
+];
+/**
+ * Adds source-derived sections after commitments have been applied.
+ *
+ * @param requirements - Requirements after commitment application and USE aggregation.
+ * @param parseResult - Parsed source used to recover non-commitment prose and examples.
+ * @param agentSource - Original source used to recover MCP server declarations.
+ * @returns Requirements with source-derived sections appended.
+ *
+ * @private function of `createAgentModelRequirementsWithCommitments`
+ */
+async function augmentAgentModelRequirementsFromSource(requirements, parseResult, agentSource) {
+    requirements = await importReferencedFiles(requirements);
+    requirements = appendMcpServers(requirements, agentSource);
+    requirements = appendNonCommitmentContent(requirements, parseResult);
+    return appendExampleInteractions(requirements, parseResult);
+}
+/**
+ * Imports text files referenced by IMPORT commitments and appends their transformed content to the system message.
+ *
+ * @param requirements - Requirements possibly containing `importedFileUrls`.
+ * @returns Requirements with imported file content appended to the system message.
+ *
+ * @private internal utility of `augmentAgentModelRequirementsFromSource`
+ */
+async function importReferencedFiles(requirements) {
+    const importedFileUrls = requirements.importedFileUrls;
+    if (!importedFileUrls || importedFileUrls.length === 0) {
+        return requirements;
+    }
+    for (const fileUrl of importedFileUrls) {
+        try {
+            const importedContent = await createImportedFileSystemMessage(fileUrl);
+            requirements = appendSystemMessageSection(requirements, importedContent);
+        }
+        catch (error) {
+            console.warn(`Failed to import file ${fileUrl}:`, error);
+        }
+    }
+    return requirements;
+}
+/**
+ * Loads, validates, and transforms one imported file into a system-message block.
+ *
+ * @param fileUrl - Remote URL or local path declared in an IMPORT commitment.
+ * @returns Imported text ready to append to the system message.
+ *
+ * @private internal utility of `importReferencedFiles`
+ */
+async function createImportedFileSystemMessage(fileUrl) {
+    await mockedSecurityCheck(fileUrl);
+    const { content, mimeType } = await readImportedFile(fileUrl);
+    if (isBinaryMimeType(mimeType)) {
+        throw new Error(`Importing binary files is not allowed: ${mimeType}`);
+    }
+    const plugin = $fileImportPlugins.find((fileImportPlugin) => fileImportPlugin.canImport(mimeType));
+    if (!plugin) {
+        throw new Error(`No import plugin found for MIME type: ${mimeType}`);
+    }
+    return plugin.import(content, mimeType);
+}
+/**
+ * Reads one imported file and normalizes the MIME type expected by file import plugins.
+ *
+ * @param fileUrl - Remote URL or local path declared in an IMPORT commitment.
+ * @returns Plain-text content together with a normalized MIME type.
+ *
+ * @private internal utility of `createImportedFileSystemMessage`
+ */
+async function readImportedFile(fileUrl) {
+    if (isValidUrl(fileUrl)) {
+        const response = await promptbookFetch(fileUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${fileUrl}: ${response.statusText}`);
+        }
+        return {
+            content: await response.text(),
+            mimeType: normalizeImportedMimeType(response.headers.get('Content-Type')),
+        };
+    }
+    /*
+    TODO: !!!! Commented out this case because we need to work in Browser-compatible mode in many packages, use passed `fs` instead
+    } else if (isValidFilePath(fileUrl)) {
+        // [x🟢x] This code is expected to run in Node environment if local files are used
+        const fs = await import('fs/promises');
+        content = await fs.readFile(fileUrl, 'utf-8');
+        const extension = getFileExtension(fileUrl);
+        mimeType = extensionToMimeType(extension as string);
+    */
+    throw new Error(`Invalid file URL or path: ${fileUrl}`);
+}
+/**
+ * Normalizes MIME types returned by fetch so plugin lookup works on bare MIME values without charset suffixes.
+ *
+ * @param mimeType - Raw response MIME type header.
+ * @returns Normalized MIME type fallbacking to `text/plain`.
+ *
+ * @private internal utility of `readImportedFile`
+ */
+function normalizeImportedMimeType(mimeType) {
+    return (mimeType || 'text/plain').split(';')[0].trim();
+}
+/**
+ * Appends extracted MCP server identifiers from the original source.
+ *
+ * @param requirements - Current requirements snapshot.
+ * @param agentSource - Original agent source used for MCP extraction.
+ * @returns Requirements with `mcpServers` set when MCP commitments are present.
+ *
+ * @private internal utility of `augmentAgentModelRequirementsFromSource`
+ */
+function appendMcpServers(requirements, agentSource) {
+    const mcpServers = extractMcpServers(agentSource);
+    if (mcpServers.length === 0) {
+        return requirements;
+    }
+    return {
+        ...requirements,
+        mcpServers,
+    };
+}
+/**
+ * Appends non-commitment prose from the source after filtering out blank lines and markdown horizontal rules.
+ *
+ * @param requirements - Current requirements snapshot.
+ * @param parseResult - Parsed source including non-commitment lines.
+ * @returns Requirements with the remaining prose appended to the system message.
+ *
+ * @private internal utility of `augmentAgentModelRequirementsFromSource`
+ */
+function appendNonCommitmentContent(requirements, parseResult) {
+    const nonCommitmentContent = getNonCommitmentContent(parseResult);
+    if (!nonCommitmentContent) {
+        return requirements;
+    }
+    return appendSystemMessageSection(requirements, nonCommitmentContent);
+}
+/**
+ * Collects plain-text lines that were not parsed as commitments and should still become part of the final system message.
+ *
+ * @param parseResult - Parsed source including non-commitment lines.
+ * @returns Joined non-commitment content or an empty string when there is nothing to append.
+ *
+ * @private internal utility of `appendNonCommitmentContent`
+ */
+function getNonCommitmentContent(parseResult) {
+    return parseResult.nonCommitmentLines
+        .filter((line, index) => index > 0 || !parseResult.agentName)
+        .filter((line) => line.trim())
+        .filter((line) => !isHorizontalLine(line))
+        .join('\n')
+        .trim();
+}
+/**
+ * Checks whether a line is a markdown horizontal separator.
+ *
+ * @param line - Source line to inspect.
+ * @returns `true` when the line is a thematic break.
+ *
+ * @private internal utility of `getNonCommitmentContent`
+ */
+function isHorizontalLine(line) {
+    return HORIZONTAL_LINE_PATTERN.test(line);
+}
+/**
+ * Appends example interactions assembled from INITIAL MESSAGE and USER/AGENT sample commitments.
+ *
+ * @param requirements - Current requirements snapshot.
+ * @param parseResult - Parsed source used to recover initial message content.
+ * @returns Requirements with the example interaction block appended when examples exist.
+ *
+ * @private internal utility of `augmentAgentModelRequirementsFromSource`
+ */
+function appendExampleInteractions(requirements, parseResult) {
+    const exampleInteractionsContent = createExampleInteractionsContent(parseResult, requirements.samples);
+    if (!exampleInteractionsContent) {
+        return requirements;
+    }
+    return appendSystemMessageSection(requirements, exampleInteractionsContent);
+}
+/**
+ * Creates the formatted example-interaction section appended to the final system message.
+ *
+ * @param parseResult - Parsed source used to recover the initial message commitment.
+ * @param samples - Parsed USER/AGENT sample pairs already stored on requirements.
+ * @returns Formatted example interaction block or `null` when no examples exist.
+ *
+ * @private internal utility of `appendExampleInteractions`
+ */
+function createExampleInteractionsContent(parseResult, samples) {
+    const examples = collectExampleInteractionLines(parseResult, samples);
+    if (examples.length === 0) {
+        return null;
+    }
+    return `Example interaction:\n\n${examples.join('\n\n')}`;
+}
+/**
+ * Collects the individual lines used in the example interaction section.
+ *
+ * @param parseResult - Parsed source used to recover the initial message commitment.
+ * @param samples - Parsed USER/AGENT sample pairs already stored on requirements.
+ * @returns Individual example interaction snippets in output order.
+ *
+ * @private internal utility of `createExampleInteractionsContent`
+ */
+function collectExampleInteractionLines(parseResult, samples) {
+    var _a;
+    const examples = [];
+    const initialMessage = (_a = parseResult.commitments.find((commitment) => commitment.type === 'INITIAL MESSAGE')) === null || _a === void 0 ? void 0 : _a.content;
+    if (initialMessage) {
+        examples.push(`Agent: ${initialMessage}`);
+    }
+    if (samples && samples.length > 0) {
+        for (const sample of samples) {
+            examples.push(`User: ${sample.question}\nAgent: ${sample.answer}`);
+        }
+    }
+    return examples;
+}
+/**
+ * Appends a single system-message section using the same blank-line separation used throughout the original implementation.
+ *
+ * @param requirements - Current requirements snapshot.
+ * @param section - Section content to append.
+ * @returns Requirements with the additional system-message block appended.
+ *
+ * @private internal utility of `augmentAgentModelRequirementsFromSource`
+ */
+function appendSystemMessageSection(requirements, section) {
+    return {
+        ...requirements,
+        systemMessage: requirements.systemMessage + '\n\n' + section,
+    };
+}
+/**
+ * Mocked security check for imported files.
+ *
+ * @param urlOrPath - The URL or local path of the file to check.
+ * @returns A promise that resolves if the file is considered safe.
+ *
+ * @private internal utility of `createImportedFileSystemMessage`
+ */
+async function mockedSecurityCheck(urlOrPath) {
+    // TODO: Implement proper security checks
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    if (urlOrPath.includes('malicious')) {
+        throw new Error(`Security check failed for: ${urlOrPath}`);
+    }
+}
+/**
+ * Checks whether the given MIME type belongs to a binary file.
+ *
+ * @param mimeType - The MIME type to check.
+ * @returns `true` when the MIME type is treated as binary.
+ *
+ * @private internal utility of `createImportedFileSystemMessage`
+ */
+function isBinaryMimeType(mimeType) {
+    return BINARY_MIME_TYPE_PREFIXES.some((prefix) => mimeType.startsWith(prefix));
+}
+
 /**
  * Parses parameters from text using both supported notations:
  * 1. @Parameter - single word parameter starting with @
@@ -33901,121 +34361,39 @@ function parseParameters(text) {
     return uniqueParameters;
 }
 
-/**
- * Removes single-hash comment lines (`# Comment`) from a system message
- * This is used to clean up the final system message before sending it to the AI model
- * while preserving the original content with comments in metadata
- *
- * @param systemMessage The system message that may contain comment lines
- * @returns The system message with single-hash comment lines removed
- *
- * @private - TODO: [🧠] Maybe should be public?
- */
-function removeCommentsFromSystemMessage(systemMessage) {
-    if (!systemMessage) {
-        return systemMessage;
-    }
-    const lines = systemMessage.split(/\r?\n/);
-    const filteredLines = lines.filter((line) => {
-        const trimmedLine = line.trim();
-        // Remove only single-hash comment markers (`# Comment`) and keep markdown headings (`## Heading`).
-        return !/^#(?!#)\s/.test(trimmedLine);
-    });
-    return filteredLines.join('\n').trim();
-}
-
-/**
- * Commitment types whose content may contain compact agent references that must be resolved before applying the commitment.
- *
- * @private internal constant of `createAgentModelRequirementsWithCommitments`
- */
-const COMMITMENTS_WITH_AGENT_REFERENCES = new Set(['FROM', 'IMPORT', 'IMPORTS', 'TEAM']);
 /**
  * DELETE-like commitment types that invalidate earlier tagged commitments.
  *
- * @private internal constant of `createAgentModelRequirementsWithCommitments`
+ * @private internal constant of `filterCommitmentsForAgentModelRequirements`
  */
 const DELETE_COMMITMENT_TYPES = new Set(['DELETE', 'CANCEL', 'DISCARD', 'REMOVE']);
 /**
  * Commitments whose earlier occurrences are overwritten by the last occurrence in source order.
  *
- * @private internal constant of `createAgentModelRequirementsWithCommitments`
+ * @private internal constant of `filterCommitmentsForAgentModelRequirements`
  */
 const OVERWRITTEN_COMMITMENT_GROUP_BY_TYPE = new Map([
     ['GOAL', 'GOAL'],
     ['GOALS', 'GOAL'],
 ]);
 /**
- * Regex pattern matching markdown horizontal lines that should not be copied into the final system message.
- *
- * @private internal constant of `createAgentModelRequirementsWithCommitments`
- */
-const HORIZONTAL_LINE_PATTERN = /^[\s]*[-_*][\s]*[-_*][\s]*[-_*][\s]*[-_*]*[\s]*$/;
-/**
- * MIME type prefixes treated as binary and therefore not eligible for text import plugins.
+ * Applies the commitment filtering rules used before commitment definitions are executed.
  *
- * @private internal constant of `createAgentModelRequirementsWithCommitments`
- */
-const BINARY_MIME_TYPE_PREFIXES = [
-    'image/',
-    'video/',
-    'audio/',
-    'application/octet-stream',
-    'application/pdf',
-    'application/zip',
-];
-/**
- * Returns a safe fallback content when a resolver fails to transform a reference commitment.
- *
- * @param commitmentType - Commitment being resolved.
- * @param originalContent - Original unresolved commitment content.
- * @returns Fallback content that keeps requirement creation resilient.
- *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
- */
-function getSafeReferenceCommitmentFallback(commitmentType, originalContent) {
-    if (commitmentType === 'FROM') {
-        return 'VOID';
-    }
-    if (commitmentType === 'IMPORT' || commitmentType === 'IMPORTS' || commitmentType === 'TEAM') {
-        return '';
-    }
-    return originalContent;
-}
-/**
- * Creates agent model requirements by parsing commitments, applying them in source order,
- * and finalizing derived sections such as imports, example interactions, and inline knowledge uploads.
- *
- * @param agentSource - Agent source book to parse.
- * @param modelName - Optional override for the agent model name.
- * @param options - Additional options such as reference and teammate resolvers.
- * @returns Fully prepared model requirements for the parsed agent source.
+ * @param commitments - Parsed commitments in original source order.
+ * @returns Commitments after DELETE-like invalidation and overwritten-goal filtering.
  *
- * @private internal utility of `createAgentModelRequirements`
+ * @private function of `createAgentModelRequirementsWithCommitments`
  */
-async function createAgentModelRequirementsWithCommitments(agentSource, modelName, options) {
-    const parseResult = parseAgentSourceWithCommitments(agentSource);
-    const filteredCommitments = filterOverwrittenCommitments(filterDeletedCommitments(parseResult.commitments));
-    let requirements = createInitialAgentModelRequirements(parseResult.agentName, modelName);
-    requirements = await applyCommitmentsToRequirements(requirements, filteredCommitments, options);
-    requirements = aggregateUseCommitmentSystemMessages(requirements, filteredCommitments);
-    requirements = await importReferencedFiles(requirements);
-    requirements = appendMcpServers(requirements, agentSource);
-    requirements = appendNonCommitmentContent(requirements, parseResult);
-    requirements = appendExampleInteractions(requirements, parseResult);
-    requirements = await applyPendingInlineKnowledgeSources(requirements, options === null || options === void 0 ? void 0 : options.inlineKnowledgeSourceUploader);
-    return finalizeRequirements(requirements);
+function filterCommitmentsForAgentModelRequirements(commitments) {
+    return filterOverwrittenCommitments(filterDeletedCommitments(commitments));
 }
 /**
  * Removes earlier commitments that are overwritten by later commitments of the same semantic group.
  *
- * This currently keeps only the last `GOAL` / `GOALS` commitment so inheritance rewrites
- * and multi-goal sources expose one effective goal to the runtime.
- *
  * @param commitments - Parsed commitments after DELETE-like filtering.
  * @returns Commitments with overwritten entries removed while preserving source order.
  *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ * @private internal utility of `filterCommitmentsForAgentModelRequirements`
  */
 function filterOverwrittenCommitments(commitments) {
     const seenOverwriteGroups = new Set();
@@ -34035,39 +34413,13 @@ function filterOverwrittenCommitments(commitments) {
     }
     return keptCommitments.reverse();
 }
-/**
- * Creates the initial requirements object with the parsed agent name stored in metadata and an optional model override.
- *
- * @param agentName - Parsed agent name from the source prelude.
- * @param modelName - Optional explicit model name override.
- * @returns Initial requirements before any commitment is applied.
- *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
- */
-function createInitialAgentModelRequirements(agentName, modelName) {
-    const initialRequirements = createBasicAgentModelRequirements(agentName);
-    const requirementsWithMetadata = {
-        ...initialRequirements,
-        _metadata: {
-            ...initialRequirements._metadata,
-            agentName,
-        },
-    };
-    if (!modelName) {
-        return requirementsWithMetadata;
-    }
-    return {
-        ...requirementsWithMetadata,
-        modelName,
-    };
-}
 /**
  * Applies DELETE-like invalidation commitments and returns only commitments that should continue through the pipeline.
  *
  * @param commitments - Parsed commitments in original source order.
  * @returns Filtered commitments with earlier deleted items removed.
  *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ * @private internal utility of `filterCommitmentsForAgentModelRequirements`
  */
 function filterDeletedCommitments(commitments) {
     const filteredCommitments = [];
@@ -34115,590 +34467,469 @@ function getCommitmentParameterNames(content) {
         .map((parameter) => parameter.name.trim().toLowerCase())
         .filter(Boolean);
 }
+
 /**
- * Applies parsed commitments one by one while keeping the per-commitment steps focused and easy to follow.
- *
- * @param requirements - Current requirements snapshot.
- * @param commitments - Commitments already filtered for DELETE-like invalidations.
- * @param options - Optional reference and teammate resolvers.
- * @returns Requirements after all applicable commitments are processed.
- *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
- */
-async function applyCommitmentsToRequirements(requirements, commitments, options) {
-    for (const [index, commitment] of commitments.entries()) {
-        if (shouldSkipCommitmentApplication(commitment, index, commitments.length)) {
-            continue;
-        }
-        const commitmentContent = await resolveCommitmentContent(commitment, options === null || options === void 0 ? void 0 : options.agentReferenceResolver);
-        requirements = await preResolveTeammateProfilesForTeamCommitment(requirements, commitment, commitmentContent, options);
-        requirements = applyCommitmentDefinitionSafely(requirements, commitment, commitmentContent);
-    }
-    return requirements;
-}
-/**
- * Resolves compact agent references for commitment types that support them.
- *
- * @param commitment - Commitment currently being applied.
- * @param agentReferenceResolver - Optional resolver for compact agent references.
- * @returns Original or resolved commitment content.
- *
- * @private internal utility of `applyCommitmentsToRequirements`
- */
-async function resolveCommitmentContent(commitment, agentReferenceResolver) {
-    if (!agentReferenceResolver || !isAgentReferenceCommitment(commitment.type)) {
-        return commitment.content;
-    }
-    try {
-        return await agentReferenceResolver.resolveCommitmentContent(commitment.type, commitment.content);
-    }
-    catch (error) {
-        console.warn(`Failed to resolve commitment references for ${commitment.type}, falling back to safe defaults:`, error);
-        return getSafeReferenceCommitmentFallback(commitment.type, commitment.content);
-    }
-}
-/**
- * Checks whether the commitment content may need agent-reference resolution before application.
- *
- * @param commitmentType - Commitment type to check.
- * @returns `true` when the commitment can contain compact agent references.
- *
- * @private internal utility of `resolveCommitmentContent`
- */
-function isAgentReferenceCommitment(commitmentType) {
-    return COMMITMENTS_WITH_AGENT_REFERENCES.has(commitmentType);
-}
-/**
- * Determines whether a commitment should be skipped before resolution or application.
- *
- * @param commitment - Commitment under consideration.
- * @param commitmentIndex - Zero-based position among filtered commitments.
- * @param commitmentCount - Total number of filtered commitments.
- * @returns `true` when the commitment should not be applied.
- *
- * @private internal utility of `applyCommitmentsToRequirements`
- */
-function shouldSkipCommitmentApplication(commitment, commitmentIndex, commitmentCount) {
-    return commitment.type === 'CLOSED' && commitmentIndex !== commitmentCount - 1;
-}
-/**
- * Pre-resolves teammate profiles for TEAM commitments so the TEAM commitment definition can reuse richer metadata.
+ * Converts staged inline knowledge files into the final knowledge source URLs stored on requirements.
  *
  * @param requirements - Current requirements snapshot.
- * @param commitment - Commitment currently being prepared.
- * @param commitmentContent - Already resolved TEAM commitment content.
- * @param options - Optional teammate profile resolvers.
- * @returns Requirements with pre-resolved teammate profiles stored in metadata when possible.
+ * @param uploader - Optional uploader for inline knowledge files.
+ * @returns Requirements with inline knowledge converted into upload URLs or data URLs.
  *
- * @private internal utility of `applyCommitmentsToRequirements`
+ * @private function of `createAgentModelRequirementsWithCommitments`
  */
-async function preResolveTeammateProfilesForTeamCommitment(requirements, commitment, commitmentContent, options) {
+async function materializeInlineKnowledgeSources(requirements, uploader) {
     var _a;
-    const profileResolver = (_a = options === null || options === void 0 ? void 0 : options.teammateProfileResolver) !== null && _a !== void 0 ? _a : options === null || options === void 0 ? void 0 : options.agentReferenceResolver;
-    if (commitment.type !== 'TEAM' || !(profileResolver === null || profileResolver === void 0 ? void 0 : profileResolver.resolveTeammateProfile)) {
+    const inlineSources = extractInlineKnowledgeSources(requirements._metadata);
+    if (inlineSources.length === 0) {
         return requirements;
     }
-    try {
-        const parsedTeammates = parseTeamCommitmentContent(commitmentContent, { strict: false });
-        const preResolvedTeammateProfiles = clonePreResolvedTeammateProfiles(requirements._metadata);
-        for (const teammate of parsedTeammates) {
-            if (preResolvedTeammateProfiles[teammate.url]) {
-                continue;
-            }
-            const profile = await profileResolver.resolveTeammateProfile(teammate.url);
-            if (profile) {
-                preResolvedTeammateProfiles[teammate.url] = profile;
-            }
-        }
-        return {
-            ...requirements,
-            _metadata: {
-                ...requirements._metadata,
-                preResolvedTeammateProfiles,
-            },
-        };
-    }
-    catch (error) {
-        console.warn('Failed to pre-resolve teammate profiles for TEAM commitment:', error);
-        return requirements;
+    const knowledgeSources = [...((_a = requirements.knowledgeSources) !== null && _a !== void 0 ? _a : [])];
+    for (const inlineSource of inlineSources) {
+        const url = uploader
+            ? await uploadInlineKnowledgeSourceWithFallback(inlineSource, uploader)
+            : inlineKnowledgeSourceToDataUrl(inlineSource);
+        knowledgeSources.push(url);
     }
-}
-/**
- * Clones the metadata bucket used to cache teammate profiles resolved ahead of TEAM commitment application.
- *
- * @param metadata - Current requirements metadata.
- * @returns Mutable copy of the cached teammate profile map.
- *
- * @private internal utility of `preResolveTeammateProfilesForTeamCommitment`
- */
-function clonePreResolvedTeammateProfiles(metadata) {
-    var _a;
     return {
-        ...((_a = metadata === null || metadata === void 0 ? void 0 : metadata.preResolvedTeammateProfiles) !== null && _a !== void 0 ? _a : {}),
+        ...requirements,
+        knowledgeSources,
+        _metadata: stripInlineKnowledgeMetadata(requirements._metadata),
     };
 }
 /**
- * Applies the registered commitment definition while isolating the failure handling from the main loop.
+ * Uploads one inline knowledge source and falls back to a data URL when the upload fails.
  *
- * @param requirements - Current requirements snapshot.
- * @param commitment - Commitment whose definition should be applied.
- * @param commitmentContent - Final content passed into the definition.
- * @returns Updated requirements, or the original requirements when the commitment fails.
+ * @param inlineSource - Inline knowledge file waiting for upload.
+ * @param uploader - Upload implementation provided by the caller.
+ * @returns Uploaded knowledge URL or a legacy data URL fallback.
  *
- * @private internal utility of `applyCommitmentsToRequirements`
+ * @private internal utility of `materializeInlineKnowledgeSources`
  */
-function applyCommitmentDefinitionSafely(requirements, commitment, commitmentContent) {
-    const definition = getCommitmentDefinition(commitment.type);
-    if (!definition) {
-        return requirements;
-    }
+async function uploadInlineKnowledgeSourceWithFallback(inlineSource, uploader) {
     try {
-        return definition.applyToAgentModelRequirements(requirements, commitmentContent);
+        return await uploader(inlineSource);
     }
     catch (error) {
-        console.warn(`Failed to apply commitment ${commitment.type}:`, error);
-        return requirements;
+        console.error('[inline-knowledge] Failed to upload inline source', {
+            filename: inlineSource.filename,
+            error,
+        });
+        return inlineKnowledgeSourceToDataUrl(inlineSource);
     }
 }
 /**
- * Imports text files referenced by IMPORT commitments and appends their transformed content to the system message.
+ * Extracts inline knowledge sources cached in commitment metadata.
  *
- * @param requirements - Requirements possibly containing `importedFileUrls`.
- * @returns Requirements with imported file content appended to the system message.
+ * @param metadata - Current requirements metadata.
+ * @returns Inline knowledge files collected during commitment application.
  *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ * @private internal utility of `materializeInlineKnowledgeSources`
  */
-async function importReferencedFiles(requirements) {
-    const importedFileUrls = requirements.importedFileUrls;
-    if (!importedFileUrls || importedFileUrls.length === 0) {
-        return requirements;
-    }
-    for (const fileUrl of importedFileUrls) {
-        try {
-            const importedContent = await createImportedFileSystemMessage(fileUrl);
-            requirements = appendSystemMessageSection(requirements, importedContent);
-        }
-        catch (error) {
-            console.warn(`Failed to import file ${fileUrl}:`, error);
-        }
+function extractInlineKnowledgeSources(metadata) {
+    if (!metadata) {
+        return [];
     }
-    return requirements;
+    const value = metadata.inlineKnowledgeSources;
+    return Array.isArray(value) ? value : [];
 }
 /**
- * Loads, validates, and transforms one imported file into a system-message block.
+ * Removes inline-knowledge staging metadata after it has been materialized into final knowledge source URLs.
  *
- * @param fileUrl - Remote URL or local path declared in an IMPORT commitment.
- * @returns Imported text ready to append to the system message.
+ * @param metadata - Current requirements metadata.
+ * @returns Metadata without the temporary inline knowledge staging field.
  *
- * @private internal utility of `importReferencedFiles`
+ * @private internal utility of `materializeInlineKnowledgeSources`
  */
-async function createImportedFileSystemMessage(fileUrl) {
-    await mockedSecurityCheck(fileUrl);
-    const { content, mimeType } = await readImportedFile(fileUrl);
-    if (isBinaryMimeType(mimeType)) {
-        throw new Error(`Importing binary files is not allowed: ${mimeType}`);
-    }
-    const plugin = $fileImportPlugins.find((fileImportPlugin) => fileImportPlugin.canImport(mimeType));
-    if (!plugin) {
-        throw new Error(`No import plugin found for MIME type: ${mimeType}`);
+function stripInlineKnowledgeMetadata(metadata) {
+    if (!metadata || !Object.prototype.hasOwnProperty.call(metadata, 'inlineKnowledgeSources')) {
+        return metadata;
     }
-    return plugin.import(content, mimeType);
+    const { inlineKnowledgeSources: _unusedInlineKnowledgeSources, ...rest } = metadata;
+    return Object.keys(rest).length > 0 ? rest : undefined;
 }
+
 /**
- * Reads one imported file and normalizes the MIME type expected by file import plugins.
+ * Removes single-hash comment lines (`# Comment`) from a system message
+ * This is used to clean up the final system message before sending it to the AI model
+ * while preserving the original content with comments in metadata
  *
- * @param fileUrl - Remote URL or local path declared in an IMPORT commitment.
- * @returns Plain-text content together with a normalized MIME type.
+ * @param systemMessage The system message that may contain comment lines
+ * @returns The system message with single-hash comment lines removed
  *
- * @private internal utility of `createImportedFileSystemMessage`
+ * @private - TODO: [🧠] Maybe should be public?
  */
-async function readImportedFile(fileUrl) {
-    if (isValidUrl(fileUrl)) {
-        const response = await promptbookFetch(fileUrl);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ${fileUrl}: ${response.statusText}`);
-        }
-        return {
-            content: await response.text(),
-            mimeType: normalizeImportedMimeType(response.headers.get('Content-Type')),
-        };
+function removeCommentsFromSystemMessage(systemMessage) {
+    if (!systemMessage) {
+        return systemMessage;
     }
-    /*
-    TODO: !!!! Commented out this case because we need to work in Browser-compatible mode in many packages, use passed `fs` instead
-    } else if (isValidFilePath(fileUrl)) {
-        // [x🟢x] This code is expected to run in Node environment if local files are used
-        const fs = await import('fs/promises');
-        content = await fs.readFile(fileUrl, 'utf-8');
-        const extension = getFileExtension(fileUrl);
-        mimeType = extensionToMimeType(extension as string);
-    */
-    throw new Error(`Invalid file URL or path: ${fileUrl}`);
+    const lines = systemMessage.split(/\r?\n/);
+    const filteredLines = lines.filter((line) => {
+        const trimmedLine = line.trim();
+        // Remove only single-hash comment markers (`# Comment`) and keep markdown headings (`## Heading`).
+        return !/^#(?!#)\s/.test(trimmedLine);
+    });
+    return filteredLines.join('\n').trim();
 }
+
 /**
- * Normalizes MIME types returned by fetch so plugin lookup works on bare MIME values without charset suffixes.
+ * Creates agent model requirements by parsing commitments, applying them in source order,
+ * and finalizing derived sections such as imports, example interactions, and inline knowledge uploads.
  *
- * @param mimeType - Raw response MIME type header.
- * @returns Normalized MIME type fallbacking to `text/plain`.
+ * @param agentSource - Agent source book to parse.
+ * @param modelName - Optional override for the agent model name.
+ * @param options - Additional options such as reference and teammate resolvers.
+ * @returns Fully prepared model requirements for the parsed agent source.
  *
- * @private internal utility of `readImportedFile`
+ * @private internal utility of `createAgentModelRequirements`
  */
-function normalizeImportedMimeType(mimeType) {
-    return (mimeType || 'text/plain').split(';')[0].trim();
+async function createAgentModelRequirementsWithCommitments(agentSource, modelName, options) {
+    const parseResult = parseAgentSourceWithCommitments(agentSource);
+    const filteredCommitments = filterCommitmentsForAgentModelRequirements(parseResult.commitments);
+    let requirements = createInitialAgentModelRequirements(parseResult.agentName, modelName);
+    requirements = await applyCommitmentsToAgentModelRequirements(requirements, filteredCommitments, options);
+    requirements = aggregateUseCommitmentSystemMessages(requirements, filteredCommitments);
+    requirements = await augmentAgentModelRequirementsFromSource(requirements, parseResult, agentSource);
+    requirements = await materializeInlineKnowledgeSources(requirements, options === null || options === void 0 ? void 0 : options.inlineKnowledgeSourceUploader);
+    return finalizeRequirements(requirements);
 }
 /**
- * Appends extracted MCP server identifiers from the original source.
+ * Creates the initial requirements object with the parsed agent name stored in metadata and an optional model override.
  *
- * @param requirements - Current requirements snapshot.
- * @param agentSource - Original agent source used for MCP extraction.
- * @returns Requirements with `mcpServers` set when MCP commitments are present.
+ * @param agentName - Parsed agent name from the source prelude.
+ * @param modelName - Optional explicit model name override.
+ * @returns Initial requirements before any commitment is applied.
  *
  * @private internal utility of `createAgentModelRequirementsWithCommitments`
  */
-function appendMcpServers(requirements, agentSource) {
-    const mcpServers = extractMcpServers(agentSource);
-    if (mcpServers.length === 0) {
-        return requirements;
+function createInitialAgentModelRequirements(agentName, modelName) {
+    const initialRequirements = createBasicAgentModelRequirements(agentName);
+    const requirementsWithMetadata = {
+        ...initialRequirements,
+        _metadata: {
+            ...initialRequirements._metadata,
+            agentName,
+        },
+    };
+    if (!modelName) {
+        return requirementsWithMetadata;
     }
     return {
-        ...requirements,
-        mcpServers,
+        ...requirementsWithMetadata,
+        modelName,
     };
 }
 /**
- * Appends non-commitment prose from the source after filtering out blank lines and markdown horizontal rules.
+ * Performs the final system-message cleanup pass after all other augmentation steps are complete.
  *
- * @param requirements - Current requirements snapshot.
- * @param parseResult - Parsed source including non-commitment lines.
- * @returns Requirements with the remaining prose appended to the system message.
+ * @param requirements - Fully built requirements before final cleanup.
+ * @returns Requirements with comment lines removed from the final system message.
  *
  * @private internal utility of `createAgentModelRequirementsWithCommitments`
  */
-function appendNonCommitmentContent(requirements, parseResult) {
-    const nonCommitmentContent = getNonCommitmentContent(parseResult);
-    if (!nonCommitmentContent) {
-        return requirements;
-    }
-    return appendSystemMessageSection(requirements, nonCommitmentContent);
+function finalizeRequirements(requirements) {
+    return {
+        ...requirements,
+        systemMessage: removeCommentsFromSystemMessage(requirements.systemMessage),
+    };
 }
+
 /**
- * Collects plain-text lines that were not parsed as commitments and should still become part of the final system message.
- *
- * @param parseResult - Parsed source including non-commitment lines.
- * @returns Joined non-commitment content or an empty string when there is nothing to append.
+ * Computes SHA-256 hash of the agent source
  *
- * @private internal utility of `appendNonCommitmentContent`
+ * @public exported from `@promptbook/core`
  */
-function getNonCommitmentContent(parseResult) {
-    return parseResult.nonCommitmentLines
-        .filter((line, index) => index > 0 || !parseResult.agentName)
-        .filter((line) => line.trim())
-        .filter((line) => !isHorizontalLine(line))
-        .join('\n')
-        .trim();
+function computeAgentHash(agentSource) {
+    return computeHash(agentSource);
 }
+
 /**
- * Checks whether a line is a markdown horizontal separator.
+ * Normalizes agent name from arbitrary string to valid agent name
  *
- * @param line - Source line to inspect.
- * @returns `true` when the line is a thematic break.
+ * Note: [🔂] This function is idempotent.
  *
- * @private internal utility of `getNonCommitmentContent`
+ * @public exported from `@promptbook/core`
  */
-function isHorizontalLine(line) {
-    return HORIZONTAL_LINE_PATTERN.test(line);
+function normalizeAgentName(rawAgentName) {
+    return titleToName(spaceTrim$1(rawAgentName));
 }
+
 /**
- * Appends example interactions assembled from INITIAL MESSAGE and USER/AGENT sample commitments.
+ * Creates temporary default agent name based on agent source hash
  *
- * @param requirements - Current requirements snapshot.
- * @param parseResult - Parsed source used to recover initial message content.
- * @returns Requirements with the example interaction block appended when examples exist.
+ * @public exported from `@promptbook/core`
+ */
+function createDefaultAgentName(agentSource) {
+    const agentHash = computeAgentHash(agentSource);
+    return normalizeAgentName(`Agent ${agentHash.substring(0, LIMITS.SHORT_NAME_LENGTH)}`);
+}
+
+/**
+ * Ensures the parsed profile always exposes a fullname value.
  *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ * @private internal utility of `parseAgentSource`
  */
-function appendExampleInteractions(requirements, parseResult) {
-    const exampleInteractionsContent = createExampleInteractionsContent(parseResult, requirements.samples);
-    if (!exampleInteractionsContent) {
-        return requirements;
+function ensureMetaFullname(meta, fallbackFullname) {
+    if (!meta.fullname) {
+        meta.fullname = fallbackFullname;
     }
-    return appendSystemMessageSection(requirements, exampleInteractionsContent);
 }
+
 /**
- * Creates the formatted example-interaction section appended to the final system message.
- *
- * @param parseResult - Parsed source used to recover the initial message commitment.
- * @param samples - Parsed USER/AGENT sample pairs already stored on requirements.
- * @returns Formatted example interaction block or `null` when no examples exist.
+ * Resolves the public agent profile text from the last GOAL/GOALS commitment,
+ * falling back to the deprecated PERSONA/PERSONAE commitments when no goal exists.
  *
- * @private internal utility of `appendExampleInteractions`
+ * @private internal utility of `parseAgentSource`
  */
-function createExampleInteractionsContent(parseResult, samples) {
-    const examples = collectExampleInteractionLines(parseResult, samples);
-    if (examples.length === 0) {
-        return null;
+function extractAgentProfileText(commitments) {
+    let goalDescription = '';
+    let hasGoalDescription = false;
+    let personaDescription = '';
+    let hasPersonaDescription = false;
+    for (const commitment of commitments) {
+        if (commitment.type === 'GOAL' || commitment.type === 'GOALS') {
+            goalDescription = commitment.content;
+            hasGoalDescription = true;
+        }
+        if (commitment.type === 'PERSONA' || commitment.type === 'PERSONAE') {
+            personaDescription = commitment.content;
+            hasPersonaDescription = true;
+        }
     }
-    return `Example interaction:\n\n${examples.join('\n\n')}`;
+    if (hasGoalDescription) {
+        return goalDescription;
+    }
+    if (hasPersonaDescription) {
+        return personaDescription;
+    }
+    return null;
 }
+
 /**
- * Collects the individual lines used in the example interaction section.
- *
- * @param parseResult - Parsed source used to recover the initial message commitment.
- * @param samples - Parsed USER/AGENT sample pairs already stored on requirements.
- * @returns Individual example interaction snippets in output order.
+ * Resolves the last INITIAL MESSAGE commitment, which is the public initial-message value.
  *
- * @private internal utility of `createExampleInteractionsContent`
+ * @private internal utility of `parseAgentSource`
  */
-function collectExampleInteractionLines(parseResult, samples) {
-    var _a;
-    const examples = [];
-    const initialMessage = (_a = parseResult.commitments.find((commitment) => commitment.type === 'INITIAL MESSAGE')) === null || _a === void 0 ? void 0 : _a.content;
-    if (initialMessage) {
-        examples.push(`Agent: ${initialMessage}`);
-    }
-    if (samples && samples.length > 0) {
-        for (const sample of samples) {
-            examples.push(`User: ${sample.question}\nAgent: ${sample.answer}`);
+function extractInitialMessage(commitments) {
+    let initialMessage = null;
+    for (const commitment of commitments) {
+        if (commitment.type === 'INITIAL MESSAGE') {
+            initialMessage = commitment.content;
         }
     }
-    return examples;
+    return initialMessage;
 }
+
 /**
- * Appends a single system-message section using the same blank-line separation used throughout the original implementation.
+ * Normalizes a domain-like string into a comparable hostname form.
  *
- * @param requirements - Current requirements snapshot.
- * @param section - Section content to append.
- * @returns Requirements with the additional system-message block appended.
+ * The returned value is lowercased and stripped to hostname only
+ * (protocol, path, query, hash, and port are removed).
  *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ * @param rawDomain - Raw domain value (for example `my-agent.com` or `https://my-agent.com/path`).
+ * @returns Normalized hostname or `null` when the value cannot be normalized.
+ *
+ * @private utility for host/domain matching
  */
-function appendSystemMessageSection(requirements, section) {
-    return {
-        ...requirements,
-        systemMessage: requirements.systemMessage + '\n\n' + section,
-    };
+function normalizeDomainForMatching(rawDomain) {
+    const trimmedDomain = rawDomain.trim();
+    if (!trimmedDomain) {
+        return null;
+    }
+    const candidateUrl = hasHttpProtocol(trimmedDomain) ? trimmedDomain : `https://${trimmedDomain}`;
+    try {
+        const parsedUrl = new URL(candidateUrl);
+        const normalizedHostname = parsedUrl.hostname.trim().toLowerCase();
+        return normalizedHostname || null;
+    }
+    catch (_a) {
+        return null;
+    }
 }
 /**
- * Performs the final system-message cleanup pass after all other augmentation steps are complete.
+ * Checks whether the value already includes an HTTP(S) protocol prefix.
  *
- * @param requirements - Fully built requirements before final cleanup.
- * @returns Requirements with comment lines removed from the final system message.
+ * @param value - Raw value to inspect.
+ * @returns True when the value starts with `http://` or `https://`.
  *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ * @private utility for host/domain matching
  */
-function finalizeRequirements(requirements) {
-    return {
-        ...requirements,
-        systemMessage: removeCommentsFromSystemMessage(requirements.systemMessage),
-    };
+function hasHttpProtocol(value) {
+    return value.startsWith('http://') || value.startsWith('https://');
 }
+
 /**
- * Attempts to upload inline knowledge entries, falling back to legacy data URLs when the upload fails or is not configured.
- *
- * @param requirements - Current requirements snapshot.
- * @param uploader - Optional uploader for inline knowledge files.
- * @returns Requirements with inline knowledge converted into upload URLs or data URLs.
+ * Dedicated handlers for META-style commitments that directly map onto parsed meta fields.
+ */
+const META_COMMITMENT_APPLIERS = {
+    'META AVATAR': applyMetaAvatarContent,
+    'META LINK': applyMetaLinkContent,
+    'META DOMAIN': applyMetaDomainContent,
+    'META IMAGE': applyMetaImageContent,
+    'META DESCRIPTION': applyMetaDescriptionContent,
+    'META DISCLAIMER': applyMetaDisclaimerContent,
+    'META INPUT PLACEHOLDER': applyMetaInputPlaceholderContent,
+    'MESSAGE SUFFIX': applyMessageSuffixContent,
+    'META COLOR': applyMetaColorContent,
+    'META FONT': applyMetaFontContent,
+    'META VOICE': applyMetaVoiceContent,
+};
+/**
+ * Applies META-style commitments that mutate parsed profile metadata.
  *
- * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ * @private internal utility of `parseAgentSource`
  */
-async function applyPendingInlineKnowledgeSources(requirements, uploader) {
-    var _a;
-    const inlineSources = extractInlineKnowledgeSources(requirements._metadata);
-    if (inlineSources.length === 0) {
-        return requirements;
+function applyMetaCommitment(state, commitment) {
+    const applyMetaContent = META_COMMITMENT_APPLIERS[commitment.type];
+    if (applyMetaContent) {
+        applyMetaContent(state, commitment.content);
+        return;
     }
-    const knowledgeSources = [...((_a = requirements.knowledgeSources) !== null && _a !== void 0 ? _a : [])];
-    for (const inlineSource of inlineSources) {
-        const url = uploader
-            ? await uploadInlineKnowledgeSourceWithFallback(inlineSource, uploader)
-            : inlineKnowledgeSourceToDataUrl(inlineSource);
-        knowledgeSources.push(url);
+    if (commitment.type === 'META') {
+        applyGenericMetaCommitment(state, commitment.content);
     }
-    return {
-        ...requirements,
-        knowledgeSources,
-        _metadata: stripInlineKnowledgeMetadata(requirements._metadata),
-    };
 }
 /**
- * Uploads one inline knowledge source and falls back to a data URL when the upload fails.
- *
- * @param inlineSource - Inline knowledge file waiting for upload.
- * @param uploader - Upload implementation provided by the caller.
- * @returns Uploaded knowledge URL or a legacy data URL fallback.
- *
- * @private internal utility of `applyPendingInlineKnowledgeSources`
+ * Applies the generic META commitment form (`META TYPE value`).
  */
-async function uploadInlineKnowledgeSourceWithFallback(inlineSource, uploader) {
-    try {
-        return await uploader(inlineSource);
+function applyGenericMetaCommitment(state, content) {
+    const metaTypeRaw = content.split(' ')[0] || 'NONE';
+    const metaValue = spaceTrim$1(content.substring(metaTypeRaw.length));
+    if (metaTypeRaw === 'LINK') {
+        state.links.push(metaValue);
     }
-    catch (error) {
-        console.error('[inline-knowledge] Failed to upload inline source', {
-            filename: inlineSource.filename,
-            error,
-        });
-        return inlineKnowledgeSourceToDataUrl(inlineSource);
+    if (metaTypeRaw.toUpperCase() === 'AVATAR') {
+        applyMetaAvatarContent(state, metaValue);
+        return;
     }
+    const metaType = normalizeTo_camelCase(metaTypeRaw);
+    state.meta[metaType] = metaValue;
 }
 /**
- * Extracts inline knowledge sources cached in commitment metadata.
- *
- * @param metadata - Current requirements metadata.
- * @returns Inline knowledge files collected during commitment application.
- *
- * @private internal utility of `applyPendingInlineKnowledgeSources`
+ * Applies META AVATAR content into the canonical `meta.avatar` field.
  */
-function extractInlineKnowledgeSources(metadata) {
-    if (!metadata) {
-        return [];
+function applyMetaAvatarContent(state, content) {
+    const avatarVisualId = resolveAvatarVisualId(content);
+    if (avatarVisualId) {
+        state.meta.avatar = avatarVisualId;
+        return;
     }
-    const value = metadata.inlineKnowledgeSources;
-    return Array.isArray(value) ? value : [];
+    delete state.meta.avatar;
 }
 /**
- * Removes inline-knowledge staging metadata after it has been materialized into final knowledge source URLs.
- *
- * @param metadata - Current requirements metadata.
- * @returns Metadata without the temporary inline knowledge staging field.
- *
- * @private internal utility of `applyPendingInlineKnowledgeSources`
+ * Applies META LINK content into links and the canonical `meta.link` field.
  */
-function stripInlineKnowledgeMetadata(metadata) {
-    if (!metadata || !Object.prototype.hasOwnProperty.call(metadata, 'inlineKnowledgeSources')) {
-        return metadata;
-    }
-    const { inlineKnowledgeSources: _unusedInlineKnowledgeSources, ...rest } = metadata;
-    return Object.keys(rest).length > 0 ? rest : undefined;
+function applyMetaLinkContent(state, content) {
+    const linkValue = spaceTrim$1(content);
+    state.links.push(linkValue);
+    state.meta.link = linkValue;
 }
 /**
- * Mocked security check for imported files.
- *
- * @param urlOrPath - The URL or local path of the file to check.
- * @returns A promise that resolves if the file is considered safe.
- *
- * @private internal utility of `createImportedFileSystemMessage`
+ * Applies META DOMAIN content into the normalized `meta.domain` field.
  */
-async function mockedSecurityCheck(urlOrPath) {
-    // TODO: Implement proper security checks
-    await new Promise((resolve) => setTimeout(resolve, 10));
-    if (urlOrPath.includes('malicious')) {
-        throw new Error(`Security check failed for: ${urlOrPath}`);
-    }
+function applyMetaDomainContent(state, content) {
+    state.meta.domain = normalizeMetaDomain(content);
+}
+/**
+ * Applies META IMAGE content into the canonical `meta.image` field.
+ */
+function applyMetaImageContent(state, content) {
+    state.meta.image = spaceTrim$1(content);
+}
+/**
+ * Applies META DESCRIPTION content into the canonical `meta.description` field.
+ */
+function applyMetaDescriptionContent(state, content) {
+    state.meta.description = spaceTrim$1(content);
+}
+/**
+ * Applies META DISCLAIMER content into the canonical `meta.disclaimer` field.
+ */
+function applyMetaDisclaimerContent(state, content) {
+    state.meta.disclaimer = content;
 }
 /**
- * Checks whether the given MIME type belongs to a binary file.
- *
- * @param mimeType - The MIME type to check.
- * @returns `true` when the MIME type is treated as binary.
- *
- * @private internal utility of `createImportedFileSystemMessage`
+ * Applies META INPUT PLACEHOLDER content into the canonical `meta.inputPlaceholder` field.
  */
-function isBinaryMimeType(mimeType) {
-    return BINARY_MIME_TYPE_PREFIXES.some((prefix) => mimeType.startsWith(prefix));
+function applyMetaInputPlaceholderContent(state, content) {
+    state.meta.inputPlaceholder = spaceTrim$1(content);
 }
-
 /**
- * Normalizes a domain-like string into a comparable hostname form.
- *
- * The returned value is lowercased and stripped to hostname only
- * (protocol, path, query, hash, and port are removed).
- *
- * @param rawDomain - Raw domain value (for example `my-agent.com` or `https://my-agent.com/path`).
- * @returns Normalized hostname or `null` when the value cannot be normalized.
- *
- * @private utility for host/domain matching
+ * Applies MESSAGE SUFFIX content into the canonical `meta.messageSuffix` field.
  */
-function normalizeDomainForMatching(rawDomain) {
-    const trimmedDomain = rawDomain.trim();
-    if (!trimmedDomain) {
-        return null;
-    }
-    const candidateUrl = hasHttpProtocol(trimmedDomain) ? trimmedDomain : `https://${trimmedDomain}`;
-    try {
-        const parsedUrl = new URL(candidateUrl);
-        const normalizedHostname = parsedUrl.hostname.trim().toLowerCase();
-        return normalizedHostname || null;
-    }
-    catch (_a) {
-        return null;
-    }
+function applyMessageSuffixContent(state, content) {
+    state.meta.messageSuffix = content;
 }
 /**
- * Checks whether the value already includes an HTTP(S) protocol prefix.
- *
- * @param value - Raw value to inspect.
- * @returns True when the value starts with `http://` or `https://`.
- *
- * @private utility for host/domain matching
+ * Applies META COLOR content into the canonical `meta.color` field.
  */
-function hasHttpProtocol(value) {
-    return value.startsWith('http://') || value.startsWith('https://');
+function applyMetaColorContent(state, content) {
+    state.meta.color = normalizeSeparator(content);
 }
-
 /**
- * Computes SHA-256 hash of the agent source
- *
- * @public exported from `@promptbook/core`
+ * Applies META FONT content into the canonical `meta.font` field.
  */
-function computeAgentHash(agentSource) {
-    return computeHash(agentSource);
+function applyMetaFontContent(state, content) {
+    state.meta.font = normalizeSeparator(content);
 }
-
 /**
- * Normalizes agent name from arbitrary string to valid agent name
- *
- * Note: [🔂] This function is idempotent.
+ * Applies META VOICE content into the canonical `meta.voice` field.
+ */
+function applyMetaVoiceContent(state, content) {
+    state.meta.voice = spaceTrim$1(content);
+}
+/**
+ * Normalizes the separator in the content
  *
- * @public exported from `@promptbook/core`
+ * @param content - The content to normalize
+ * @returns The content with normalized separators
  */
-function normalizeAgentName(rawAgentName) {
-    return titleToName(spaceTrim$1(rawAgentName));
+function normalizeSeparator(content) {
+    const trimmed = spaceTrim$1(content);
+    if (trimmed.includes(',')) {
+        return trimmed;
+    }
+    return trimmed.split(/\s+/).join(', ');
 }
-
 /**
- * Creates temporary default agent name based on agent source hash
+ * Normalizes META DOMAIN content to a hostname-like value when possible.
  *
- * @public exported from `@promptbook/core`
+ * @param content - Raw META DOMAIN content.
+ * @returns Normalized domain or a trimmed fallback.
  */
-function createDefaultAgentName(agentSource) {
-    const agentHash = computeAgentHash(agentSource);
-    return normalizeAgentName(`Agent ${agentHash.substring(0, LIMITS.SHORT_NAME_LENGTH)}`);
+function normalizeMetaDomain(content) {
+    const trimmed = spaceTrim$1(content);
+    return normalizeDomainForMatching(trimmed) || trimmed.toLowerCase();
 }
 
 /**
- * Parses basic information from agent source
- *
- * There are 2 similar functions:
- * - `parseAgentSource` which is a lightweight parser for agent source, it parses basic information and its purpose is to be quick and synchronous. The commitments there are hardcoded.
- * - `createAgentModelRequirements` which is an asynchronous function that creates model requirements it applies each commitment one by one and works asynchronously.
+ * Updates sample-conversation state for communication commitments.
  *
- * @public exported from `@promptbook/core`
+ * @private internal utility of `parseAgentSource`
  */
-function parseAgentSource(agentSource) {
-    const parseResult = parseAgentSourceWithCommitments(agentSource);
-    const resolvedAgentName = parseResult.agentName || createDefaultAgentName(agentSource);
-    const personaDescription = extractAgentProfileText(parseResult.commitments);
-    const initialMessage = extractInitialMessage(parseResult.commitments);
-    const parsedProfile = extractParsedAgentProfile(parseResult.commitments);
-    ensureMetaFullname(parsedProfile.meta, resolvedAgentName);
-    return {
-        agentName: normalizeAgentName(resolvedAgentName),
-        agentHash: computeAgentHash(agentSource),
-        permanentId: parsedProfile.meta.id,
-        personaDescription,
-        initialMessage,
-        meta: parsedProfile.meta,
-        links: parsedProfile.links,
-        parameters: parseParameters(agentSource),
-        capabilities: parsedProfile.capabilities,
-        samples: parsedProfile.samples,
-        knowledgeSources: parsedProfile.knowledgeSources,
-    };
+function consumeConversationSampleCommitment(state, commitment) {
+    switch (commitment.type) {
+        case 'INITIAL MESSAGE':
+            state.samples.push({ question: null, answer: commitment.content });
+            return true;
+        case 'USER MESSAGE':
+            state.pendingUserMessage = commitment.content;
+            return true;
+        case 'INTERNAL MESSAGE':
+            // INTERNAL MESSAGE stores trace payloads and is intentionally ignored in basic profile samples.
+            return true;
+        case 'AGENT MESSAGE':
+            if (state.pendingUserMessage !== null) {
+                state.samples.push({ question: state.pendingUserMessage, answer: commitment.content });
+                state.pendingUserMessage = null;
+            }
+            return true;
+        default:
+            return false;
+    }
 }
+
 /**
  * Static capability descriptors for commitments that map one-to-one to a visible capability.
- *
- * @private internal utility of `parseAgentSource`
  */
 const SIMPLE_CAPABILITY_BY_COMMITMENT_TYPE = {
     'USE BROWSER': {
@@ -34762,141 +34993,10 @@ const SIMPLE_CAPABILITY_BY_COMMITMENT_TYPE = {
         iconName: 'Calendar',
     },
 };
-/**
- * Dedicated handlers for META-style commitments that directly map onto parsed meta fields.
- *
- * @private internal utility of `parseAgentSource`
- */
-const META_COMMITMENT_APPLIERS = {
-    'META AVATAR': applyMetaAvatarContent,
-    'META LINK': applyMetaLinkContent,
-    'META DOMAIN': applyMetaDomainContent,
-    'META IMAGE': applyMetaImageContent,
-    'META DESCRIPTION': applyMetaDescriptionContent,
-    'META DISCLAIMER': applyMetaDisclaimerContent,
-    'META INPUT PLACEHOLDER': applyMetaInputPlaceholderContent,
-    'MESSAGE SUFFIX': applyMessageSuffixContent,
-    'META COLOR': applyMetaColorContent,
-    'META FONT': applyMetaFontContent,
-    'META VOICE': applyMetaVoiceContent,
-};
 /**
  * Detects local slash-based references used by FROM and IMPORT commitments.
- *
- * @private internal utility of `parseAgentSource`
  */
 const LOCAL_AGENT_REFERENCE_PREFIXES = ['./', '../', '/'];
-/**
- * Resolves the public agent profile text from the last GOAL/GOALS commitment,
- * falling back to the deprecated PERSONA/PERSONAE commitments when no goal exists.
- *
- * @private internal utility of `parseAgentSource`
- */
-function extractAgentProfileText(commitments) {
-    let goalDescription = '';
-    let hasGoalDescription = false;
-    let personaDescription = '';
-    let hasPersonaDescription = false;
-    for (const commitment of commitments) {
-        if (commitment.type === 'GOAL' || commitment.type === 'GOALS') {
-            goalDescription = commitment.content;
-            hasGoalDescription = true;
-        }
-        if (commitment.type === 'PERSONA' || commitment.type === 'PERSONAE') {
-            personaDescription = commitment.content;
-            hasPersonaDescription = true;
-        }
-    }
-    if (hasGoalDescription) {
-        return goalDescription;
-    }
-    if (hasPersonaDescription) {
-        return personaDescription;
-    }
-    return null;
-}
-/**
- * Resolves the last INITIAL MESSAGE commitment, which is the public initial-message value.
- *
- * @private internal utility of `parseAgentSource`
- */
-function extractInitialMessage(commitments) {
-    let initialMessage = null;
-    for (const commitment of commitments) {
-        if (commitment.type === 'INITIAL MESSAGE') {
-            initialMessage = commitment.content;
-        }
-    }
-    return initialMessage;
-}
-/**
- * Collects capability, sample, meta, link, and knowledge-source data from commitments.
- *
- * @private internal utility of `parseAgentSource`
- */
-function extractParsedAgentProfile(commitments) {
-    const state = {
-        meta: {},
-        links: [],
-        capabilities: [],
-        samples: [],
-        knowledgeSources: [],
-        pendingUserMessage: null,
-        knownKnowledgeSourceUrls: new Set(),
-    };
-    for (const commitment of commitments) {
-        processParsedCommitment(state, commitment);
-    }
-    return {
-        meta: state.meta,
-        links: state.links,
-        capabilities: state.capabilities,
-        samples: state.samples,
-        knowledgeSources: state.knowledgeSources,
-    };
-}
-/**
- * Processes one parsed commitment through the sample, capability, and meta stages.
- *
- * @private internal utility of `parseAgentSource`
- */
-function processParsedCommitment(state, commitment) {
-    if (consumeConversationSampleCommitment(state, commitment)) {
-        return;
-    }
-    const capabilities = createCapabilitiesFromCommitment(state, commitment);
-    if (capabilities.length > 0) {
-        state.capabilities.push(...capabilities);
-        return;
-    }
-    applyMetaCommitment(state, commitment);
-}
-/**
- * Updates sample-conversation state for communication commitments.
- *
- * @private internal utility of `parseAgentSource`
- */
-function consumeConversationSampleCommitment(state, commitment) {
-    switch (commitment.type) {
-        case 'INITIAL MESSAGE':
-            state.samples.push({ question: null, answer: commitment.content });
-            return true;
-        case 'USER MESSAGE':
-            state.pendingUserMessage = commitment.content;
-            return true;
-        case 'INTERNAL MESSAGE':
-            // INTERNAL MESSAGE stores trace payloads and is intentionally ignored in basic profile samples.
-            return true;
-        case 'AGENT MESSAGE':
-            if (state.pendingUserMessage !== null) {
-                state.samples.push({ question: state.pendingUserMessage, answer: commitment.content });
-                state.pendingUserMessage = null;
-            }
-            return true;
-        default:
-            return false;
-    }
-}
 /**
  * Creates the visible capabilities produced by one parsed commitment.
  *
@@ -34926,8 +35026,6 @@ function createCapabilitiesFromCommitment(state, commitment) {
 }
 /**
  * Clones one static capability descriptor for a simple capability commitment.
- *
- * @private internal utility of `parseAgentSource`
  */
 function createSimpleCapability(commitmentType) {
     const capability = SIMPLE_CAPABILITY_BY_COMMITMENT_TYPE[commitmentType];
@@ -34935,8 +35033,6 @@ function createSimpleCapability(commitmentType) {
 }
 /**
  * Creates the USE PROJECT capability badge.
- *
- * @private internal utility of `parseAgentSource`
  */
 function createProjectCapability(content) {
     var _a;
@@ -34950,8 +35046,6 @@ function createProjectCapability(content) {
 }
 /**
  * Creates the FROM inheritance capability when the reference should stay visible in the profile.
- *
- * @private internal utility of `parseAgentSource`
  */
 function createInheritanceCapability(content) {
     const reference = extractFirstCommitmentLine(content);
@@ -34978,8 +35072,6 @@ function createInheritanceCapability(content) {
 }
 /**
  * Creates the IMPORT capability badge.
- *
- * @private internal utility of `parseAgentSource`
  */
 function createImportCapability(content) {
     const reference = extractFirstCommitmentLine(content);
@@ -35007,8 +35099,6 @@ function createImportCapability(content) {
 }
 /**
  * Creates TEAM capability badges for all parsed teammates.
- *
- * @private internal utility of `parseAgentSource`
  */
 function createTeamCapabilities(content) {
     const teammates = parseTeamCommitmentContent(content);
@@ -35021,8 +35111,6 @@ function createTeamCapabilities(content) {
 }
 /**
  * Creates the KNOWLEDGE capability badge and records URL-based knowledge sources.
- *
- * @private internal utility of `parseAgentSource`
  */
 function createKnowledgeCapability(state, content) {
     const trimmedContent = spaceTrim$1(content);
@@ -35037,8 +35125,6 @@ function createKnowledgeCapability(state, content) {
 }
 /**
  * Stores unique URL-based knowledge sources for later citation resolution.
- *
- * @private internal utility of `parseAgentSource`
  */
 function rememberKnowledgeSources(state, extractedUrls) {
     for (const extractedUrl of extractedUrls) {
@@ -35062,8 +35148,6 @@ function rememberKnowledgeSources(state, extractedUrls) {
 }
 /**
  * Derives the visible KNOWLEDGE badge label and icon from commitment content.
- *
- * @private internal utility of `parseAgentSource`
  */
 function createKnowledgeCapabilityPresentation(content, extractedUrls) {
     let label = content;
@@ -35096,8 +35180,6 @@ function createKnowledgeCapabilityPresentation(content, extractedUrls) {
 }
 /**
  * Shortens text-only KNOWLEDGE commitments into the same preview label as before.
- *
- * @private internal utility of `parseAgentSource`
  */
 function createKnowledgeTextLabel(content) {
     const words = content.split(/\s+/);
@@ -35106,186 +35188,89 @@ function createKnowledgeTextLabel(content) {
     }
     return content;
 }
-/**
- * Applies META-style commitments that mutate parsed profile metadata.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaCommitment(state, commitment) {
-    const applyMetaContent = META_COMMITMENT_APPLIERS[commitment.type];
-    if (applyMetaContent) {
-        applyMetaContent(state, commitment.content);
-        return;
-    }
-    if (commitment.type === 'META') {
-        applyGenericMetaCommitment(state, commitment.content);
-    }
-}
-/**
- * Applies the generic META commitment form (`META TYPE value`).
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyGenericMetaCommitment(state, content) {
-    const metaTypeRaw = content.split(' ')[0] || 'NONE';
-    const metaValue = spaceTrim$1(content.substring(metaTypeRaw.length));
-    if (metaTypeRaw === 'LINK') {
-        state.links.push(metaValue);
-    }
-    if (metaTypeRaw.toUpperCase() === 'AVATAR') {
-        applyMetaAvatarContent(state, metaValue);
-        return;
-    }
-    const metaType = normalizeTo_camelCase(metaTypeRaw);
-    state.meta[metaType] = metaValue;
-}
-/**
- * Applies META AVATAR content into the canonical `meta.avatar` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaAvatarContent(state, content) {
-    const avatarVisualId = resolveAvatarVisualId(content);
-    if (avatarVisualId) {
-        state.meta.avatar = avatarVisualId;
-        return;
-    }
-    delete state.meta.avatar;
-}
-/**
- * Applies META LINK content into links and the canonical `meta.link` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaLinkContent(state, content) {
-    const linkValue = spaceTrim$1(content);
-    state.links.push(linkValue);
-    state.meta.link = linkValue;
-}
-/**
- * Applies META DOMAIN content into the normalized `meta.domain` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaDomainContent(state, content) {
-    state.meta.domain = normalizeMetaDomain(content);
-}
-/**
- * Applies META IMAGE content into the canonical `meta.image` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaImageContent(state, content) {
-    state.meta.image = spaceTrim$1(content);
-}
-/**
- * Applies META DESCRIPTION content into the canonical `meta.description` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaDescriptionContent(state, content) {
-    state.meta.description = spaceTrim$1(content);
-}
-/**
- * Applies META DISCLAIMER content into the canonical `meta.disclaimer` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaDisclaimerContent(state, content) {
-    state.meta.disclaimer = content;
-}
-/**
- * Applies META INPUT PLACEHOLDER content into the canonical `meta.inputPlaceholder` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaInputPlaceholderContent(state, content) {
-    state.meta.inputPlaceholder = spaceTrim$1(content);
-}
-/**
- * Applies MESSAGE SUFFIX content into the canonical `meta.messageSuffix` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMessageSuffixContent(state, content) {
-    state.meta.messageSuffix = content;
-}
-/**
- * Applies META COLOR content into the canonical `meta.color` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaColorContent(state, content) {
-    state.meta.color = normalizeSeparator(content);
-}
-/**
- * Applies META FONT content into the canonical `meta.font` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaFontContent(state, content) {
-    state.meta.font = normalizeSeparator(content);
-}
-/**
- * Applies META VOICE content into the canonical `meta.voice` field.
- *
- * @private internal utility of `parseAgentSource`
- */
-function applyMetaVoiceContent(state, content) {
-    state.meta.voice = spaceTrim$1(content);
-}
-/**
- * Ensures the parsed profile always exposes a fullname value.
- *
- * @private internal utility of `parseAgentSource`
- */
-function ensureMetaFullname(meta, fallbackFullname) {
-    if (!meta.fullname) {
-        meta.fullname = fallbackFullname;
-    }
-}
 /**
  * Extracts the first logical line from multiline commitment content.
- *
- * @private internal utility of `parseAgentSource`
  */
 function extractFirstCommitmentLine(content) {
     return spaceTrim$1(content).split(/\r?\n/)[0] || '';
 }
 /**
  * Detects local FROM/IMPORT references that should use local-link labels and icons.
- *
- * @private internal utility of `parseAgentSource`
  */
 function isLocalAgentReference(reference) {
     return LOCAL_AGENT_REFERENCE_PREFIXES.some((prefix) => reference.startsWith(prefix));
 }
+
 /**
- * Normalizes the separator in the content
- *
- * @param content - The content to normalize
- * @returns The content with normalized separators
+ * Collects capability, sample, meta, link, and knowledge-source data from commitments.
  *
  * @private internal utility of `parseAgentSource`
  */
-function normalizeSeparator(content) {
-    const trimmed = spaceTrim$1(content);
-    if (trimmed.includes(',')) {
-        return trimmed;
+function extractParsedAgentProfile(commitments) {
+    const state = {
+        meta: {},
+        links: [],
+        capabilities: [],
+        samples: [],
+        knowledgeSources: [],
+        pendingUserMessage: null,
+        knownKnowledgeSourceUrls: new Set(),
+    };
+    for (const commitment of commitments) {
+        processParsedCommitment(state, commitment);
     }
-    return trimmed.split(/\s+/).join(', ');
+    return {
+        meta: state.meta,
+        links: state.links,
+        capabilities: state.capabilities,
+        samples: state.samples,
+        knowledgeSources: state.knowledgeSources,
+    };
 }
 /**
- * Normalizes META DOMAIN content to a hostname-like value when possible.
+ * Processes one parsed commitment through the sample, capability, and meta stages.
+ */
+function processParsedCommitment(state, commitment) {
+    if (consumeConversationSampleCommitment(state, commitment)) {
+        return;
+    }
+    const capabilities = createCapabilitiesFromCommitment(state, commitment);
+    if (capabilities.length > 0) {
+        state.capabilities.push(...capabilities);
+        return;
+    }
+    applyMetaCommitment(state, commitment);
+}
+
+/**
+ * Parses basic information from agent source
  *
- * @param content - Raw META DOMAIN content.
- * @returns Normalized domain or a trimmed fallback.
+ * There are 2 similar functions:
+ * - `parseAgentSource` which is a lightweight parser for agent source, it parses basic information and its purpose is to be quick and synchronous. The commitments there are hardcoded.
+ * - `createAgentModelRequirements` which is an asynchronous function that creates model requirements it applies each commitment one by one and works asynchronously.
  *
- * @private internal utility of `parseAgentSource`
+ * @public exported from `@promptbook/core`
  */
-function normalizeMetaDomain(content) {
-    const trimmed = spaceTrim$1(content);
-    return normalizeDomainForMatching(trimmed) || trimmed.toLowerCase();
+function parseAgentSource(agentSource) {
+    const parseResult = parseAgentSourceWithCommitments(agentSource);
+    const resolvedAgentName = parseResult.agentName || createDefaultAgentName(agentSource);
+    const personaDescription = extractAgentProfileText(parseResult.commitments);
+    const initialMessage = extractInitialMessage(parseResult.commitments);
+    const parsedProfile = extractParsedAgentProfile(parseResult.commitments);
+    ensureMetaFullname(parsedProfile.meta, resolvedAgentName);
+    return {
+        agentName: normalizeAgentName(resolvedAgentName),
+        agentHash: computeAgentHash(agentSource),
+        permanentId: parsedProfile.meta.id,
+        personaDescription,
+        initialMessage,
+        meta: parsedProfile.meta,
+        links: parsedProfile.links,
+        parameters: parseParameters(agentSource),
+        capabilities: parsedProfile.capabilities,
+        samples: parsedProfile.samples,
+        knowledgeSources: parsedProfile.knowledgeSources,
+    };
 }
 // TODO: [🕛] Unite `AgentBasicInformation`, `ChatParticipant`, `LlmExecutionTools` +  `LlmToolsMetadata`