@promptbook/core 0.113.0-9 → 0.114.0-0

package/esm/index.es.js

@@ -28,7 +28,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.113.0-9';
+const PROMPTBOOK_ENGINE_VERSION = '0.114.0-0';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -11906,6 +11906,7 @@ class MessageSuffixCommitmentDefinition extends BaseCommitmentDefinition {
  * - META TITLE: Sets the agent's display title
  * - META DESCRIPTION: Sets the agent's description
  * - META INPUT PLACEHOLDER: Sets chat input placeholder text
+ * - META THINKING MESSAGE: Adds custom thinking placeholder variants
  * - META [ANYTHING]: Any other meta information in uppercase format
  *
  * These commitments are special because they don't affect the system message,
@@ -11921,6 +11922,7 @@ class MessageSuffixCommitmentDefinition extends BaseCommitmentDefinition {
  * META TITLE Professional Assistant
  * META DESCRIPTION An AI assistant specialized in business tasks
  * META INPUT PLACEHOLDER Write a message...
+ * META THINKING MESSAGE Thinking...
  * META AUTHOR John Doe
  * META VERSION 1.0
  * ```
@@ -11961,6 +11963,7 @@ class MetaCommitmentDefinition extends BaseCommitmentDefinition {
             - **META TITLE** - Sets the agent's display title
             - **META DESCRIPTION** - Sets the agent's description
             - **META INPUT PLACEHOLDER** - Sets chat input placeholder text
+            - **META THINKING MESSAGE** - Adds custom thinking placeholder variants
             - **META [ANYTHING]** - Any other meta information in uppercase format
 
             ## Key aspects
@@ -11969,6 +11972,7 @@ class MetaCommitmentDefinition extends BaseCommitmentDefinition {
             - Used for visual representation and attribution in user interfaces
             - Multiple META commitments of different types can be used
             - Multiple META LINK commitments can be used for different social profiles
+            - Multiple META THINKING MESSAGE commitments can be used for different thinking placeholder variants
             - If multiple META commitments of the same type are specified, the last one takes precedence (except for LINK)
 
             ## Examples
@@ -18767,6 +18771,68 @@ class MetaLinkCommitmentDefinition extends BaseCommitmentDefinition {
 }
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
+/**
+ * META THINKING MESSAGE commitment definition.
+ *
+ * The `META THINKING MESSAGE` commitment adds one custom thinking placeholder
+ * variant used by chat UIs while an agent is composing a reply.
+ *
+ * @private Metadata-only commitment used by Agents Server chat UIs.
+ */
+class MetaThinkingMessageCommitmentDefinition extends BaseCommitmentDefinition {
+    constructor() {
+        super('META THINKING MESSAGE');
+    }
+    /**
+     * Short one-line description of META THINKING MESSAGE.
+     */
+    get description() {
+        return 'Add a custom thinking placeholder shown while the agent replies.';
+    }
+    /**
+     * Icon for this commitment.
+     */
+    get icon() {
+        return '💭';
+    }
+    /**
+     * Markdown documentation for META THINKING MESSAGE commitment.
+     */
+    get documentation() {
+        return spaceTrim$1(`
+            # META THINKING MESSAGE
+
+            Adds one custom placeholder variant shown while the agent is composing a reply.
+
+            ## Key aspects
+
+            - Does not modify model behavior, system message, or tools.
+            - Multiple \`META THINKING MESSAGE\` commitments define multiple variants.
+            - Chat UIs randomly rotate between the configured variants while the reply is running.
+            - When no non-empty variants are configured, the server-level \`THINKING_MESSAGES\` metadata is used.
+            - Supports multiline markdown content.
+
+            ## Example
+
+            \`\`\`book
+            Helpful Assistant
+
+            META THINKING MESSAGE Thinking...
+            META THINKING MESSAGE Processing...
+            META THINKING MESSAGE
+
+            Doing
+            extra **hard** work
+            \`\`\`
+        `);
+    }
+    applyToAgentModelRequirements(requirements, content) {
+        // META THINKING MESSAGE is metadata only and does not alter model requirements.
+        return requirements;
+    }
+}
+// Note: [💞] Ignore a discrepancy between file name and entity name
+
 /**
  * META VISIBILITY commitment definition.
  *
@@ -20845,6 +20911,7 @@ class UseBrowserCommitmentDefinition extends BaseCommitmentDefinition {
               1. **One-shot URL fetching**: Simple function to fetch and scrape URL content (active)
               2. **Running browser**: For complex tasks like scrolling, clicking, form filling, etc. (runtime-dependent)
             - The actual browser tool usage is handled by the agent runtime
+            - On the Agents Server, every agent browses in its own persistent isolated browser profile, so cookies and logged-in sessions survive across chats (the profile is linked from the agent wallet)
             - Allows the agent to fetch current information from websites and documents
             - Useful for research tasks, fact-checking, and accessing dynamic content
             - Supports various content types including HTML pages and PDF documents
@@ -27355,6 +27422,7 @@ const COMMITMENT_REGISTRY = [
     new MetaDomainCommitmentDefinition(),
     new MetaDisclaimerCommitmentDefinition(),
     new MetaInputPlaceholderCommitmentDefinition(),
+    new MetaThinkingMessageCommitmentDefinition(),
     new MetaVisibilityCommitmentDefinition(),
     new MetaCommitmentDefinition(),
     new MetaVoiceCommitmentDefinition(),
@@ -28697,6 +28765,7 @@ const META_COMMITMENT_APPLIERS = {
     'META DESCRIPTION': applyMetaDescriptionContent,
     'META DISCLAIMER': applyMetaDisclaimerContent,
     'META INPUT PLACEHOLDER': applyMetaInputPlaceholderContent,
+    'META THINKING MESSAGE': applyMetaThinkingMessageContent,
     'MESSAGE SUFFIX': applyMessageSuffixContent,
     'META COLOR': applyMetaColorContent,
     'META FONT': applyMetaFontContent,
@@ -28787,6 +28856,16 @@ function applyMetaDisclaimerContent(state, content) {
 function applyMetaInputPlaceholderContent(state, content) {
     state.meta.inputPlaceholder = spaceTrim$1(content);
 }
+/**
+ * Applies one META THINKING MESSAGE content block into the custom thinking-message variants.
+ */
+function applyMetaThinkingMessageContent(state, content) {
+    const thinkingMessage = spaceTrim$1(content);
+    if (!thinkingMessage) {
+        return;
+    }
+    state.thinkingMessages = [...(state.thinkingMessages || []), thinkingMessage];
+}
 /**
  * Applies MESSAGE SUFFIX content into the canonical `meta.messageSuffix` field.
  */
@@ -29155,6 +29234,7 @@ function extractParsedAgentProfile(commitments) {
         capabilities: [],
         samples: [],
         knowledgeSources: [],
+        thinkingMessages: [],
         pendingUserMessage: null,
         knownKnowledgeSourceUrls: new Set(),
     };
@@ -29167,6 +29247,7 @@ function extractParsedAgentProfile(commitments) {
         capabilities: state.capabilities,
         samples: state.samples,
         knowledgeSources: state.knowledgeSources,
+        thinkingMessages: state.thinkingMessages,
     };
 }
 /**
@@ -29206,6 +29287,7 @@ function parseAgentSource(agentSource) {
         permanentId: parsedProfile.meta.id,
         personaDescription,
         initialMessage,
+        thinkingMessages: parsedProfile.thinkingMessages,
         meta: parsedProfile.meta,
         links: parsedProfile.links,
         parameters: parseParameters(agentSource),
@@ -29379,84 +29461,6 @@ const DEFAULT_BOOK = padBook(validateBook(spaceTrim$1(`
 //                  <- [🐱‍🚀] Buttons into genesis book
 // <- TODO: [🐱‍🚀] generateBookBoilerplate and deprecate `DEFAULT_BOOK`
 
-/**
- * Warning message used for unfinished commitments.
- */
-const UNFINISHED_COMMITMENT_MESSAGE = 'This commitment is unfinished and not ready to use. Be careful when using it.';
-/**
- * Low-level warning message used for low-level commitments.
- */
-const LOW_LEVEL_COMMITMENT_MESSAGE = 'This commitment is low-level and not used by most of the users. Be careful when using it.';
-/**
- * Short badge text used for deprecated commitments.
- */
-const DEPRECATED_COMMITMENT_BADGE_LABEL = 'Deprecated';
-/**
- * Short badge text used for unfinished and low-level commitments.
- */
-const LOW_LEVEL_COMMITMENT_BADGE_LABEL = 'Low-level';
-/**
- * Longer label used for deprecated commitments.
- */
-const DEPRECATED_COMMITMENT_DETAIL_LABEL = 'Deprecated commitment';
-/**
- * Longer label used for unfinished and low-level commitments.
- */
-const LOW_LEVEL_COMMITMENT_DETAIL_LABEL = 'Low-level commitment';
-/**
- * Prefix used when formatting replacement guidance.
- */
-const PREFERRED_REPLACEMENT_LABEL = 'Preferred replacement';
-/**
- * Formats preferred replacement guidance for deprecated commitments.
- *
- * @param replacedBy - Preferred replacement commitment keywords.
- * @returns Optional replacement guidance sentence with leading space.
- *
- * @private internal utility of commitment catalog notices
- */
-function formatCommitmentReplacementText(replacedBy) {
-    if (!replacedBy || replacedBy.length === 0) {
-        return '';
-    }
-    return ` ${PREFERRED_REPLACEMENT_LABEL}: ${replacedBy.map((type) => `\`${type}\``).join(', ')}.`;
-}
-/**
- * Resolves the notice metadata for deprecated, unfinished, or low-level commitments.
- *
- * @param definition - Commitment definition to inspect.
- * @returns Notice metadata when the commitment should be surfaced with caution.
- *
- * @private internal utility of commitment catalog notices
- */
-function getCommitmentNoticeMetadata(definition) {
-    if (definition.isUnfinished) {
-        return {
-            kind: 'unfinished',
-            badgeLabel: LOW_LEVEL_COMMITMENT_BADGE_LABEL,
-            detailLabel: LOW_LEVEL_COMMITMENT_DETAIL_LABEL,
-            message: UNFINISHED_COMMITMENT_MESSAGE,
-        };
-    }
-    if (definition.isLowLevel) {
-        return {
-            kind: 'lowLevel',
-            badgeLabel: LOW_LEVEL_COMMITMENT_BADGE_LABEL,
-            detailLabel: LOW_LEVEL_COMMITMENT_DETAIL_LABEL,
-            message: LOW_LEVEL_COMMITMENT_MESSAGE,
-        };
-    }
-    if (definition.deprecation) {
-        return {
-            kind: 'deprecated',
-            badgeLabel: DEPRECATED_COMMITMENT_BADGE_LABEL,
-            detailLabel: DEPRECATED_COMMITMENT_DETAIL_LABEL,
-            message: definition.deprecation.message,
-        };
-    }
-    return null;
-}
-
 /**
  * Priority order for the important commitments shown first in catalogues and intellisense.
  *
@@ -29613,52 +29617,18 @@ function findExistingCommitmentGroup(groupedCommitments, commitment) {
         group.primary.constructor === commitment.constructor) || null);
 }
 
-/**
- * Common anti-patterns with practical fixes.
- *
- * @private internal utility of `createStandaloneBookLanguageMarkdown`
- */
-const bookLanguageCommonPitfalls = [
-    {
-        title: 'Too broad agent scope',
-        dont: 'One agent tries to be a lawyer, developer, marketer, and researcher at once.',
-        doInstead: 'Split into focused agents and orchestrate with TEAM or IMPORT.',
-    },
-    {
-        title: 'Unverifiable claims',
-        dont: 'The agent answers internet-dependent questions without tools or without citing sources.',
-        doInstead: 'Add `USE SEARCH ENGINE` / `USE BROWSER` and a citation-oriented `RULE`.',
-    },
-    {
-        title: 'Missing guardrails',
-        dont: 'Only persona is defined, with no behavioral constraints.',
-        doInstead: 'Add concrete `RULE` commitments for safety, scope, and tone.',
-    },
-    {
-        title: 'Overloaded inheritance',
-        dont: 'Using deep `FROM` chains without documenting why each parent is needed.',
-        doInstead: 'Keep inheritance shallow and use focused IMPORT/TEAM composition for reuse.',
-    },
-    {
-        title: 'Unsafe memory usage',
-        dont: 'Storing every detail in memory without boundaries.',
-        doInstead: 'Pair `MEMORY` with explicit rules about what is allowed to persist.',
-    },
-];
-
 /**
  * End-to-end examples used by the standalone Book language documentation.
  *
  * These are intentionally compact but complete, so they can be copy-pasted and
- * used as practical starting points.
+ * used as practical starting points. Their prose lives in the manual
+ * dictionaries, keyed by the `id` of each example.
  *
  * @private internal utility of `createStandaloneBookLanguageMarkdown`
  */
 const bookLanguageDocumentationExamples = [
     {
         id: 'minimal-hello-world-agent',
-        title: 'Minimal hello-world agent',
-        goal: 'Create the smallest useful agent with identity and greeting.',
         source: spaceTrim$1(`
             Hello World Agent
 
@@ -29666,17 +29636,9 @@ const bookLanguageDocumentationExamples = [
             INITIAL MESSAGE Hello! I am ready to help.
             CLOSED
         `),
-        walkthrough: [
-            'The first line (`Hello World Agent`) is the agent name.',
-            '`GOAL` defines the effective role and profile text.',
-            '`INITIAL MESSAGE` sets a deterministic first message for a new chat.',
-            '`CLOSED` prevents conversational self-modification.',
-        ],
     },
     {
         id: 'tool-using-browser-search-agent',
-        title: 'Tool-using agent (Browser + Search engine)',
-        goal: 'Enable internet research with clear sourcing behavior.',
         source: spaceTrim$1(`
             Web Research Assistant
 
@@ -29687,17 +29649,9 @@ const bookLanguageDocumentationExamples = [
             RULE Include source links in your final answer.
             INITIAL MESSAGE Ask me what topic you want to research and how deep the report should be.
         `),
-        walkthrough: [
-            '`USE SEARCH ENGINE` provides web search tooling and optional search instructions.',
-            '`USE BROWSER` enables URL fetching and interactive browsing tools.',
-            '`RULE` commitments make reliability behavior explicit and repeatable.',
-            'This pattern is ideal for current-events and fact-checking agents.',
-        ],
     },
     {
         id: 'rule-and-knowledge-agent',
-        title: 'Agent with RULE and KNOWLEDGE',
-        goal: 'Ground responses in explicit constraints and curated sources.',
         source: spaceTrim$1(`
             Support Policy Assistant
 
@@ -29708,17 +29662,9 @@ const bookLanguageDocumentationExamples = [
             RULE Never invent legal or policy statements.
             INITIAL MESSAGE I can explain refund and support rules from provided knowledge.
         `),
-        walkthrough: [
-            '`KNOWLEDGE` may be inline text or an external URL/document.',
-            '`RULE` commitments define non-negotiable behavior constraints.',
-            'Combining both creates predictable, grounded policy responses.',
-            'Use this pattern for compliance, support, and internal procedures.',
-        ],
     },
     {
         id: 'memory-agent-with-long-term-memory',
-        title: 'MEMORY agent with long-term memory',
-        goal: 'Persist user preferences across conversations.',
         source: spaceTrim$1(`
             Customer Success Memory Agent
 
@@ -29728,17 +29674,9 @@ const bookLanguageDocumentationExamples = [
             RULE Never store secrets or sensitive data unless explicitly requested and allowed.
             INITIAL MESSAGE I can remember your setup and preferences for future sessions.
         `),
-        walkthrough: [
-            '`MEMORY` adds runtime memory tools and memory-specific system guidance.',
-            '`RULE` commitments narrow what should be remembered to reduce privacy risks.',
-            'In Agents Server, memory is runtime-backed and user-scoped.',
-            'Use this for assistants that must preserve context over time.',
-        ],
     },
     {
         id: 'use-project-and-wallet-integration-agent',
-        title: 'USE PROJECT and WALLET external integration',
-        goal: 'Work with GitHub repositories and wallet-backed credentials.',
         source: spaceTrim$1(`
             Repository Maintainer
 
@@ -29749,17 +29687,9 @@ const bookLanguageDocumentationExamples = [
             RULE Never reveal raw credentials in chat output.
             INITIAL MESSAGE I can inspect the repository and help you prepare PR-ready changes.
         `),
-        walkthrough: [
-            '`USE PROJECT` enables repository tools for listing, reading, editing files, and creating PRs.',
-            'Credentials are resolved from wallet records at runtime in Agents Server.',
-            '`WALLET` is kept here as a compatibility marker, but current Book 2.0 parsing treats it as deprecated/ignored.',
-            'In current runtime behavior, wallet-backed integrations are driven by commitments such as `USE PROJECT` and `USE EMAIL`.',
-        ],
     },
     {
         id: 'use-calendar-integration-agent',
-        title: 'USE CALENDAR integration',
-        goal: 'Coordinate meetings and schedules through a connected Google Calendar.',
         source: spaceTrim$1(`
             Calendar Assistant
 
@@ -29769,17 +29699,9 @@ const bookLanguageDocumentationExamples = [
             RULE Confirm destructive actions before deleting an event.
             INITIAL MESSAGE Tell me the meeting details and I will schedule it in your calendar.
         `),
-        walkthrough: [
-            '`USE CALENDAR` enables calendar tools for listing, reading, creating, updating, and deleting events.',
-            'The first calendar URL identifies which calendar integration should be used.',
-            '`SCOPES` can explicitly request required Google Calendar OAuth permissions.',
-            'Credentials are resolved from wallet-backed Google Calendar OAuth records at runtime in Agents Server.',
-        ],
     },
     {
         id: 'agents-team-example',
-        title: 'Agents TEAM (with in-book teammates)',
-        goal: 'Delegate sub-tasks to specialized teammates.',
         source: spaceTrim$1(`
             Team Manager
 
@@ -29805,85 +29727,1076 @@ const bookLanguageDocumentationExamples = [
             RULE Estimate complexity and identify blockers.
             CLOSED
         `),
-        walkthrough: [
-            'The main agent delegates via `TEAM` commitment.',
-            'References in `{...}` are resolved against embedded agents inside the same book (split by `---`).',
-            'Each teammate can be isolated with `FROM VOID` for deterministic specialization.',
-            'This pattern works well for multi-role review and decision support.',
-        ],
     },
 ];
 
 /**
- * Canonical commitment keyword for the open/closed family.
- *
- * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ * Warning message used for unfinished commitments.
  */
-const OPEN_COMMITMENT_TYPE = 'OPEN';
+const UNFINISHED_COMMITMENT_MESSAGE = 'This commitment is unfinished and not ready to use. Be careful when using it.';
 /**
- * Canonical commitment keyword for the open/closed family.
+ * Low-level warning message used for low-level commitments.
  */
-const CLOSED_COMMITMENT_TYPE = 'CLOSED';
+const LOW_LEVEL_COMMITMENT_MESSAGE = 'This commitment is low-level and not used by most of the users. Be careful when using it.';
 /**
- * Removes the top-level heading from one commitment documentation block.
+ * Short badge text used for deprecated commitments.
+ */
+const DEPRECATED_COMMITMENT_BADGE_LABEL = 'Deprecated';
+/**
+ * Short badge text used for unfinished and low-level commitments.
+ */
+const LOW_LEVEL_COMMITMENT_BADGE_LABEL = 'Low-level';
+/**
+ * Longer label used for deprecated commitments.
+ */
+const DEPRECATED_COMMITMENT_DETAIL_LABEL = 'Deprecated commitment';
+/**
+ * Longer label used for unfinished and low-level commitments.
+ */
+const LOW_LEVEL_COMMITMENT_DETAIL_LABEL = 'Low-level commitment';
+/**
+ * Prefix used when formatting replacement guidance.
+ */
+const PREFERRED_REPLACEMENT_LABEL = 'Preferred replacement';
+/**
+ * Formats preferred replacement guidance for deprecated commitments.
  *
- * @param markdown - Original markdown source.
- * @returns Markdown without the first `#` heading.
+ * @param replacedBy - Preferred replacement commitment keywords.
+ * @returns Optional replacement guidance sentence with leading space.
  *
- * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ * @private internal utility of commitment catalog notices
  */
-function removeLeadingTopLevelHeading(markdown) {
-    return markdown.replace(/^\s*#\s+[^\n]+\n*/u, '').trim();
+function formatCommitmentReplacementText(replacedBy) {
+    if (!replacedBy || replacedBy.length === 0) {
+        return '';
+    }
+    return ` ${PREFERRED_REPLACEMENT_LABEL}: ${replacedBy.map((type) => `\`${type}\``).join(', ')}.`;
 }
 /**
- * Renders one subsection for the combined open/closed documentation family.
+ * Returns true when one commitment notice should be rendered with low-visibility styling.
  *
- * @param title - Heading label for the subsection.
- * @param documentation - Raw commitment documentation markdown.
- * @returns Markdown subsection with a `####` heading.
+ * @param notice - Commitment notice metadata or null.
+ * @returns True for unfinished and low-level notices.
  *
- * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ * @private internal utility of commitment catalog notices
  */
-function renderDocumentationSection(title, documentation) {
-    return spaceTrim$1((block) => `
-            #### ${title}
-
-            ${block(removeLeadingTopLevelHeading(documentation))}
-        `);
+function isLowVisibilityCommitmentNotice(notice) {
+    return Boolean(notice && notice.kind !== 'deprecated');
 }
 /**
- * Renders the documentation body for one grouped commitment entry.
+ * Resolves the notice metadata for deprecated, unfinished, or low-level commitments.
  *
- * `OPEN` and `CLOSED` are intentionally rendered together so the documentation
- * surfaces present them as one conceptual switch instead of two isolated pages.
+ * @param definition - Commitment definition to inspect.
+ * @returns Notice metadata when the commitment should be surfaced with caution.
  *
- * @param group - Grouped commitment metadata.
- * @returns Markdown body for the docs page/catalog entry.
+ * @private internal utility of commitment catalog notices
+ */
+function getCommitmentNoticeMetadata(definition) {
+    if (definition.isUnfinished) {
+        return {
+            kind: 'unfinished',
+            badgeLabel: LOW_LEVEL_COMMITMENT_BADGE_LABEL,
+            detailLabel: LOW_LEVEL_COMMITMENT_DETAIL_LABEL,
+            message: UNFINISHED_COMMITMENT_MESSAGE,
+        };
+    }
+    if (definition.isLowLevel) {
+        return {
+            kind: 'lowLevel',
+            badgeLabel: LOW_LEVEL_COMMITMENT_BADGE_LABEL,
+            detailLabel: LOW_LEVEL_COMMITMENT_DETAIL_LABEL,
+            message: LOW_LEVEL_COMMITMENT_MESSAGE,
+        };
+    }
+    if (definition.deprecation) {
+        return {
+            kind: 'deprecated',
+            badgeLabel: DEPRECATED_COMMITMENT_BADGE_LABEL,
+            detailLabel: DEPRECATED_COMMITMENT_DETAIL_LABEL,
+            message: definition.deprecation.message,
+        };
+    }
+    return null;
+}
+
+/**
+ * Splits the commitment registry into the groups documented by the manual.
+ *
+ * Deprecated commitments are intentionally left out completely, so that the
+ * manual never teaches a keyword that should no longer be written into a book.
+ *
+ * @returns Commitment groups for the main catalog and for the low-level chapter.
  *
  * @private internal utility of `createStandaloneBookLanguageMarkdown`
  */
-function renderGroupedCommitmentDocumentationMarkdown(group) {
-    const commitmentTypes = new Set([group.primary.type, ...group.aliases]);
-    if (commitmentTypes.has(OPEN_COMMITMENT_TYPE) && commitmentTypes.has(CLOSED_COMMITMENT_TYPE)) {
-        const openCommitmentDefinition = getCommitmentDefinition(OPEN_COMMITMENT_TYPE);
-        const closedCommitmentDefinition = getCommitmentDefinition(CLOSED_COMMITMENT_TYPE);
-        if (openCommitmentDefinition && closedCommitmentDefinition) {
-            return spaceTrim$1((block) => `
-                    ${block(renderDocumentationSection(OPEN_COMMITMENT_TYPE, openCommitmentDefinition.documentation))}
-
-                    ${block(renderDocumentationSection(CLOSED_COMMITMENT_TYPE, closedCommitmentDefinition.documentation))}
-                `);
+function getBookLanguageManualCommitmentGroups() {
+    const documented = [];
+    const lowLevel = [];
+    for (const groupedCommitment of getGroupedCommitmentDefinitions()) {
+        const notice = getCommitmentNoticeMetadata(groupedCommitment.primary);
+        if ((notice === null || notice === void 0 ? void 0 : notice.kind) === 'deprecated') {
+            continue;
+        }
+        if (isLowVisibilityCommitmentNotice(notice)) {
+            lowLevel.push(groupedCommitment);
+            continue;
         }
+        documented.push(groupedCommitment);
     }
-    return removeLeadingTopLevelHeading(group.primary.documentation);
+    return { documented, lowLevel };
 }
 
 /**
- * Commitment types that primarily model composition of multiple agents.
+ * Czech translation of the standalone Book language manual.
  *
- * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ * Commitment keywords are intentionally kept in English, because they are part
+ * of the Book language syntax and must be written exactly as-is.
+ *
+ * @private internal constant of `createStandaloneBookLanguageMarkdown`
  */
-const COMPOSITION_COMMITMENT_TYPES = new Set(['FROM', 'IMPORT', 'IMPORTS', 'TEAM']);
+const czechBookLanguageManualDictionary = {
+    language: 'cs',
+    title: 'Příručka jazyka Book',
+    introLines: [
+        'Ucelený samostatný průvodce jazykem Book pro agenty Promptbooku.',
+        'Vygenerováno z repozitáře https://github.com/webgptorg/promptbook',
+    ],
+    metadataLabels: {
+        bookLanguageVersion: 'Verze jazyka Book',
+        generatedAt: 'Vygenerováno',
+        commitmentGroups: 'Skupin commitmentů',
+        implementedCommitments: 'Hotových commitmentů',
+        placeholderCommitments: 'Připravovaných commitmentů',
+    },
+    tableOfContentsTitle: 'Obsah',
+    chapters: {
+        whatIs: {
+            title: 'Co je jazyk Book',
+            body: spaceTrim$1(`
+                Book je doménově specifický jazyk pro zápis **AI agentů** v podobě prostého textu.
+                Řeší tyto problémy:
+
+                - **Jediný upravitelný zdroj pravdy** pro chování agenta, nástroje, paměť i profilová metadata.
+                - **Skládatelná architektura agentů** pomocí commitmentů jako \`FROM\`, \`IMPORT\` a \`TEAM\`.
+                - **Předvídatelná příprava běhu**, kdy se zdroj rozparsuje a přeloží do požadavků na model.
+                - **Přenositelné definice agentů**, které lze kopírovat, verzovat a revidovat jako text.
+
+                V tomto repozitáři znamená „jazyk Book“ vždy **jazyk agentů Book 2.0**.
+            `),
+        },
+        mentalModel: {
+            title: 'Jak o agentovi přemýšlet',
+            body: spaceTrim$1(`
+                Na zdroj jednoho agenta se dívejte jako na čtyři vrstvy:
+
+                1. **Vrstva identity a profilu**:
+                Jméno agenta (první řádek, který není commitment), poslední \`GOAL\` a commitmenty \`META*\`.
+                2. **Vrstva chování**:
+                \`RULE\`, \`KNOWLEDGE\`, \`WRITING SAMPLE\`, \`WRITING RULES\`, \`LANGUAGE\`, \`GOAL\` a příbuzné commitmenty.
+                3. **Vrstva schopností**:
+                \`USE*\`, \`MEMORY\` a další nástrojové commitmenty, které agentovi otevírají běhové schopnosti.
+                4. **Vrstva skládání**:
+                Dědičnost přes \`FROM\`, znovupoužití přes \`IMPORT\` a delegování přes \`TEAM\`.
+            `),
+        },
+        howToStructure: {
+            title: 'Jak psát dobré agenty',
+            body: spaceTrim$1(`
+                Doporučené postupy a jejich kompromisy:
+
+                1. **Nejdřív jedna jasná role**:
+                Začněte jedním úzce vymezeným \`GOAL\`, který popisuje, za co agent odpovídá.
+                Kompromis: menší počáteční volnost, výrazně vyšší spolehlivost.
+                2. **Mantinely hned na začátku**:
+                Přidejte konkrétní commitmenty \`RULE\` dřív, než začnete přidávat nástroje.
+                Kompromis: víc přemýšlení předem, míň překvapení za běhu.
+                3. **Opora ve zdrojích místo improvizace**:
+                U odpovědí s vysokou cenou chyby dejte přednost \`KNOWLEDGE\` a výslovnému pravidlu o citování.
+                Kompromis: údržba zdrojů navíc, lepší kontrola nad fakty.
+                4. **Skládání místo jednoho velkého agenta**:
+                Na specializované odpovědnosti použijte \`TEAM\` nebo \`IMPORT\`.
+                Kompromis: režie s koordinací, výrazně lepší modularita a znovupoužitelnost.
+                5. **Řízená paměť**:
+                Pokud používáte \`MEMORY\`, popište, co se pamatovat má a co v žádném případě ne.
+                Kompromis: přísnější návrh pravidel, lepší soukromí i kvalita zapamatovaného.
+            `),
+        },
+        primitives: {
+            title: 'Přehled stavebních prvků',
+            body: '',
+        },
+        commitmentCatalog: {
+            title: 'Katalog commitmentů',
+            body: spaceTrim$1(`
+                Tato kapitola se generuje z definic commitmentů v \`src/commitments\`.
+                U každé skupiny commitmentů najdete:
+
+                - shrnutí významu (popis, ikona, stav)
+                - schéma pro parsování (\`createTypeRegex\` a \`createRegex\`)
+                - úplnou dokumentaci
+
+                Klíčová slova commitmentů jsou součástí syntaxe, a proto zůstávají anglicky.
+                Anglicky zůstávají i jejich referenční popisy, které jsou závaznou specifikací jazyka.
+            `),
+        },
+        examples: {
+            title: 'Ucelené příklady',
+        },
+        pitfalls: {
+            title: 'Časté chyby a čemu se vyhnout',
+        },
+        tutorial: {
+            title: 'Postavte agenta od nuly (návod bez internetu)',
+            body: spaceTrim$1(`
+                Tento návod si vystačí bez přístupu k internetu.
+
+                1. **Určete roli a cíl**
+                Napište krátký řádek se jménem a jeden srozumitelný \`GOAL\`.
+                2. **Přidejte mantinely chování**
+                Přidejte 3-6 konkrétních commitmentů \`RULE\` pro rozsah, tón a bezpečnostní hranice.
+                3. **Přidejte oporu ve znalostech**
+                Přidejte commitmenty \`KNOWLEDGE\` (přímý text, nebo lokální či importovatelné zdroje).
+                4. **Přidejte schopnosti**
+                Přidejte jen ty commitmenty \`USE*\` a \`MEMORY\`, které agent opravdu potřebuje.
+                5. **Doplňte profilová metadata**
+                Přidejte \`META DESCRIPTION\`, \`META AVATAR\` / \`META VISUAL\` nebo \`META IMAGE\`, \`META INPUT PLACEHOLDER\`, \`META THINKING MESSAGE\` a případná upozornění.
+                6. **Připravte první interakci**
+                Přidejte \`INITIAL MESSAGE\` a případně ukázkové dvojice \`USER MESSAGE\` / \`AGENT MESSAGE\`.
+                7. **Uzavřete agenta pro předvídatelné chování (volitelné)**
+                Přidejte \`CLOSED\`, pokud chcete stabilní chování bez úprav za chodu.
+            `),
+        },
+        lowLevelCommitments: {
+            title: 'Nízkoúrovňové commitmenty',
+            body: spaceTrim$1(`
+                Následující commitmenty jsou plnohodnotnou součástí jazyka Book, ale jsou určené jen pro pokročilé použití.
+                Většina agentů je nikdy nepotřebuje a jejich nesprávné použití agenta zbytečně zkomplikuje.
+
+                Sáhněte po nich teprve tehdy, když konkrétní technický požadavek nejde vyjádřit commitmenty z předchozích kapitol.
+            `),
+        },
+    },
+    mentalModelSections: {
+        detectedIntro: 'Commitmenty pro skládání agentů v aktuálním běhovém prostředí:',
+        detectedProfileLabel: 'Nalezené commitmenty pro profil',
+        detectedBehaviorLabel: 'Nalezené commitmenty pro chování',
+        detectedToolingLabel: 'Nalezené commitmenty pro nástroje a běh',
+        detectedCompositionLabel: 'Nalezené commitmenty pro skládání',
+        meta: {
+            title: 'Commitmenty META a profil agenta',
+            body: spaceTrim$1(`
+                Commitmenty \`META*\` řídí profilová data zobrazovaná v rozhraní (například avatar, obrázek, popis, upozornění, doménu nebo text v poli pro zprávu).
+                Ovlivňují spíš prezentaci a metadata než chování nástrojů.
+            `),
+        },
+        inheritance: {
+            title: 'Dědičnost přes FROM',
+            body: spaceTrim$1(`
+                \`FROM\` odkazuje na zdroj rodičovského agenta. Při vyhodnocení dědičnosti platí:
+
+                - Obsah rodiče se sloučí do výsledného zdroje.
+                - \`FROM {Void}\` / \`FROM VOID\` znamená výslovné „žádný rodič“.
+                - Chybějící odkazy se do výsledného zdroje propíší jako poznámky.
+            `),
+        },
+        composition: {
+            title: 'TEAM a IMPORT',
+            body: spaceTrim$1(`
+                - \`TEAM\` zpřístupní kolegy jako nástroje, které lze zavolat.
+                - \`IMPORT\` vloží obsah importovaného agenta nebo souboru do kontextu agenta.
+                - V Agents Serveru se zkrácené odkazy jako \`{Legal Reviewer}\` umí navázat na agenty vložené přímo v knize.
+            `),
+        },
+        capabilities: {
+            title: 'Commitmenty USE',
+            body: spaceTrim$1(`
+                Commitmenty \`USE*\` zapínají schopnosti (vyhledávání, prohlížeč, napojení na projekt, e-mail, generování obrázků a další).
+                Zpřístupňují běhové nástroje a doplňují pokyny do systémové zprávy.
+            `),
+        },
+    },
+    primitivesSections: {
+        coreSyntax: {
+            title: 'Základní prvky syntaxe',
+            body: spaceTrim$1(`
+                1. **Jméno agenta**:
+                První neprázdný řádek, který není klíčovým slovem commitmentu.
+                2. **Blok commitmentu**:
+                Začíná klíčovým slovem commitmentu a pokračuje až k dalšímu commitmentu nebo oddělovači.
+                3. **Vodorovný oddělovač**:
+                Řádky jako \`---\` dělí zdroj na části; v Agents Serveru jimi lze oddělit agenty vložené přímo v knize.
+                4. **Bloky kódu**:
+                Uvnitř obsahu commitmentu zůstávají zachované; hodí se pro ukázky a instrukce.
+                5. **Parametry**:
+                Podporovaný a rozpoznávaný je zápis \`@parametr\` i \`{parametr}\`.
+            `),
+        },
+        references: {
+            title: 'Odkazy a zástupní agenti',
+            body: spaceTrim$1(`
+                - Zkrácené odkazy jako \`{Jméno agenta}\` vyhodnocuje resolver odkazů v Agents Serveru.
+                - V příslušných commitmentech lze použít i zástupné agenty (například \`{User}\` nebo \`{Void}\`).
+                - \`{User}\` je určený pro \`TEAM\`; \`{Void}\` se hodí pro výslovné zrušení dědičnosti.
+            `),
+        },
+        keywordsTitle: 'Aktuálně rozpoznávaná klíčová slova commitmentů',
+    },
+    commitmentCatalogTitleSuffixes: {
+        usedFirst: ' (nejdřív používané commitmenty)',
+        all: ' (všechny commitmenty)',
+    },
+    commitmentLabels: {
+        status: 'Stav',
+        aliases: 'Varianty zápisu',
+        semantics: 'Význam',
+        typeSchema: 'Schéma klíčového slova',
+        blockSchema: 'Schéma bloku',
+        lowLevelNotice: 'Nízkoúrovňový commitment',
+        usage: 'Použití u vybraných agentů',
+        usageOccurrence: 'výskyt',
+        usageOccurrences: 'výskytů',
+        statusImplemented: 'Hotovo',
+        statusPlaceholder: 'Připravuje se (zatím není plně hotové)',
+        noAliases: 'Žádné',
+    },
+    exampleLabels: {
+        commitmentsUsed: 'Použité commitmenty',
+        fullSource: 'Celý zdroj',
+        goal: 'Cíl',
+        walkthrough: 'Rozbor',
+        noCommitments: 'Žádné',
+    },
+    exampleTexts: {
+        'minimal-hello-world-agent': {
+            title: 'Nejmenší funkční agent',
+            goal: 'Vytvořit nejmenšího užitečného agenta s identitou a pozdravem.',
+            walkthrough: [
+                'První řádek (`Hello World Agent`) je jméno agenta.',
+                '`GOAL` určuje výslednou roli a text profilu.',
+                '`INITIAL MESSAGE` nastavuje předvídatelnou první zprávu nové konverzace.',
+                '`CLOSED` brání tomu, aby se agent upravoval během konverzace.',
+            ],
+        },
+        'tool-using-browser-search-agent': {
+            title: 'Agent s nástroji (prohlížeč a vyhledávač)',
+            goal: 'Umožnit rešerši na internetu s jasnou prací se zdroji.',
+            walkthrough: [
+                '`USE SEARCH ENGINE` zpřístupní vyhledávání na webu a volitelné pokyny k němu.',
+                '`USE BROWSER` zapne stahování adres a interaktivní procházení webu.',
+                'Commitmenty `RULE` dělají požadavky na spolehlivost výslovnými a opakovatelnými.',
+                'Tento vzor se hodí pro agenty na aktuální dění a ověřování faktů.',
+            ],
+        },
+        'rule-and-knowledge-agent': {
+            title: 'Agent s RULE a KNOWLEDGE',
+            goal: 'Opřít odpovědi o výslovná omezení a připravené zdroje.',
+            walkthrough: [
+                '`KNOWLEDGE` může být přímý text i externí adresa nebo dokument.',
+                'Commitmenty `RULE` definují nepřekročitelná omezení chování.',
+                'Jejich kombinace vede k předvídatelným a doloženým odpovědím.',
+                'Tento vzor použijte pro compliance, podporu a interní postupy.',
+            ],
+        },
+        'memory-agent-with-long-term-memory': {
+            title: 'Agent s dlouhodobou pamětí (MEMORY)',
+            goal: 'Uchovat preference uživatele napříč konverzacemi.',
+            walkthrough: [
+                '`MEMORY` přidá běhové nástroje paměti a příslušné pokyny do systémové zprávy.',
+                'Commitmenty `RULE` zúží, co se smí pamatovat, a snižují tak rizika pro soukromí.',
+                'V Agents Serveru je paměť vedená za běhu a je vázaná na konkrétního uživatele.',
+                'Hodí se pro asistenty, kteří si musí držet kontext v čase.',
+            ],
+        },
+        'use-project-and-wallet-integration-agent': {
+            title: 'Napojení na projekt (USE PROJECT) a peněženku',
+            goal: 'Pracovat s repozitáři na GitHubu a s přihlašovacími údaji z peněženky.',
+            walkthrough: [
+                '`USE PROJECT` zapne nástroje pro výpis, čtení a úpravy souborů a pro zakládání pull requestů.',
+                'Přihlašovací údaje se v Agents Serveru za běhu načtou ze záznamů v peněžence.',
+                '`WALLET` je zde ponechaný jen kvůli zpětné kompatibilitě, aktuální parsování Book 2.0 ho ignoruje.',
+                'V současném chování zajišťují napojení s přihlašovacími údaji commitmenty jako `USE PROJECT` a `USE EMAIL`.',
+            ],
+        },
+        'use-calendar-integration-agent': {
+            title: 'Napojení na kalendář (USE CALENDAR)',
+            goal: 'Domlouvat schůzky a hlídat program v napojeném Google Kalendáři.',
+            walkthrough: [
+                '`USE CALENDAR` zapne nástroje pro výpis, čtení, zakládání, úpravy a mazání událostí.',
+                'První adresa kalendáře určuje, které napojení se má použít.',
+                '`SCOPES` umí výslovně vyžádat potřebná oprávnění OAuth pro Google Kalendář.',
+                'Přihlašovací údaje se v Agents Serveru za běhu načtou ze záznamů OAuth v peněžence.',
+            ],
+        },
+        'agents-team-example': {
+            title: 'Tým agentů (TEAM s kolegy v jedné knize)',
+            goal: 'Předávat dílčí úkoly specializovaným kolegům.',
+            walkthrough: [
+                'Hlavní agent deleguje práci commitmentem `TEAM`.',
+                'Odkazy v `{...}` se vyhodnocují proti agentům vloženým ve stejné knize (oddělených pomocí `---`).',
+                'Každého kolegu lze pomocí `FROM VOID` oddělit a získat tak předvídatelnou specializaci.',
+                'Tento vzor se osvědčuje u vícerolových revizí a podpory rozhodování.',
+            ],
+        },
+    },
+    pitfallLabels: {
+        dont: 'Nedělejte',
+        doInstead: 'Udělejte místo toho',
+    },
+    pitfalls: [
+        {
+            title: 'Příliš široké zadání agenta',
+            dont: 'Jeden agent má být zároveň právník, vývojář, marketér i rešeršista.',
+            doInstead: 'Rozdělte ho na soustředěné agenty a propojte je pomocí TEAM nebo IMPORT.',
+        },
+        {
+            title: 'Neověřitelná tvrzení',
+            dont: 'Agent odpovídá na otázky závislé na internetu bez nástrojů nebo bez uvedení zdrojů.',
+            doInstead: 'Přidejte `USE SEARCH ENGINE` / `USE BROWSER` a `RULE` zaměřené na citování.',
+        },
+        {
+            title: 'Chybějící mantinely',
+            dont: 'Je vyplněný jen cíl agenta a žádná omezení chování.',
+            doInstead: 'Přidejte konkrétní commitmenty `RULE` pro bezpečnost, rozsah a tón.',
+        },
+        {
+            title: 'Přetížená dědičnost',
+            dont: 'Dlouhé řetězce `FROM` bez vysvětlení, proč je každý rodič potřeba.',
+            doInstead: 'Držte dědičnost mělkou a pro znovupoužití sáhněte po cíleném IMPORT nebo TEAM.',
+        },
+        {
+            title: 'Nebezpečné zacházení s pamětí',
+            dont: 'Ukládání každého detailu do paměti bez jakýchkoli hranic.',
+            doInstead: 'Doplňte `MEMORY` výslovnými pravidly, co se smí uchovávat.',
+        },
+    ],
+    tutorialSections: {
+        serverAgentsHint: 'Vyjděte z některého z ukázkových agentů tohoto serveru výše a ponechte jen ty commitmenty, které nový agent potřebuje.',
+        templateIntro: 'Šablona ke zkopírování:',
+        checklistTitle: 'Kontrolní seznam:',
+        checklistBody: spaceTrim$1(`
+            - Má každý commitment jasný účel?
+            - Jsou výslovně ošetřené vymyšlené odpovědi a nebezpečné chování?
+            - Jsou zapnuté jen ty nástroje, které jsou opravdu potřeba?
+            - Je práce s pamětí omezená srozumitelnými pravidly?
+            - Je skládání (\`FROM\`/\`TEAM\`/\`IMPORT\`) opodstatněné a pochopitelné?
+        `),
+    },
+    footer: {
+        title: 'Vygenerováno z:',
+        body: spaceTrim$1(`
+            - Registru commitmentů a běhové dokumentace v \`src/commitments\`
+            - Chování parseru a překladače v \`src/book-2.0/agent-source\`
+            - Vyhodnocení odkazů a dědičnosti v Agents Serveru v \`apps/agents-server/src/utils\`
+            - Zdrojových bloků samostatné dokumentace v \`apps/agents-server/src/utils/bookLanguageDocumentation\`
+        `),
+    },
+};
+
+/**
+ * Canonical English wording of the standalone Book language manual.
+ *
+ * Every other language pack is a translation of this dictionary and is resolved
+ * through `getBookLanguageManualDictionary`.
+ *
+ * @private internal constant of `createStandaloneBookLanguageMarkdown`
+ */
+const englishBookLanguageManualDictionary = {
+    language: 'en',
+    title: 'Book Language blueprint',
+    introLines: [
+        'Canonical standalone guide for Promptbook Book Agent language.',
+        'Generated from repository https://github.com/webgptorg/promptbook',
+    ],
+    metadataLabels: {
+        bookLanguageVersion: 'Book language version',
+        generatedAt: 'Generated at',
+        commitmentGroups: 'Commitment groups',
+        implementedCommitments: 'Implemented commitments',
+        placeholderCommitments: 'Placeholder commitments',
+    },
+    tableOfContentsTitle: 'Table of Contents',
+    chapters: {
+        whatIs: {
+            title: 'What Book language is',
+            body: spaceTrim$1(`
+                Book language is a domain-specific language for defining **AI agents** as plain-text source.
+                It solves these problems:
+
+                - **One editable source of truth** for agent behavior, tools, memory, and profile metadata.
+                - **Composable agent architecture** through commitments like \`FROM\`, \`IMPORT\`, and \`TEAM\`.
+                - **Deterministic runtime preparation** where source is parsed and compiled into model requirements.
+                - **Portable agent definitions** that can be copied, versioned, and reviewed as text.
+
+                In this repository, "Book language" means **Book 2.0 agent language**.
+            `),
+        },
+        mentalModel: {
+            title: 'Mental model of an agent',
+            body: spaceTrim$1(`
+                Think of one agent source as four layers:
+
+                1. **Identity/Profile layer**:
+                Agent name (first non-commitment line), the last \`GOAL\`, and \`META*\` commitments.
+                2. **Behavior layer**:
+                \`RULE\`, \`KNOWLEDGE\`, \`WRITING SAMPLE\`, \`WRITING RULES\`, \`LANGUAGE\`, \`GOAL\`, and related commitments.
+                3. **Capability layer**:
+                \`USE*\`, \`MEMORY\`, and other tooling commitments exposing runtime abilities.
+                4. **Composition layer**:
+                \`FROM\` inheritance, \`IMPORT\` reuse, and \`TEAM\` delegation.
+            `),
+        },
+        howToStructure: {
+            title: 'How to structure good agents',
+            body: spaceTrim$1(`
+                Recommended patterns and tradeoffs:
+
+                1. **Single clear role first**:
+                Start with one narrow \`GOAL\` describing what the agent is responsible for.
+                Tradeoff: less initial flexibility, much higher reliability.
+                2. **Guardrails early**:
+                Add concrete \`RULE\` commitments before adding many tools.
+                Tradeoff: more upfront design, fewer runtime surprises.
+                3. **Grounding over improvisation**:
+                Prefer \`KNOWLEDGE\` + explicit citation rule for high-stakes answers.
+                Tradeoff: extra maintenance for sources, better factual control.
+                4. **Composition over monoliths**:
+                Use \`TEAM\`/\`IMPORT\` for specialized responsibilities.
+                Tradeoff: orchestration overhead, stronger modularity and reuse.
+                5. **Controlled memory**:
+                If using \`MEMORY\`, define what must and must not be remembered.
+                Tradeoff: stricter policy design, better privacy and signal quality.
+            `),
+        },
+        primitives: {
+            title: 'Primitives and constructs reference',
+            body: '',
+        },
+        commitmentCatalog: {
+            title: 'Commitment catalog',
+            body: spaceTrim$1(`
+                This section is generated from commitment definitions in \`src/commitments\`.
+                For each commitment group you get:
+
+                - semantics summary (description/icon/status)
+                - parsing schema (\`createTypeRegex\` and \`createRegex\`)
+                - canonical documentation block
+            `),
+        },
+        examples: {
+            title: 'End-to-end examples',
+        },
+        pitfalls: {
+            title: 'Do nots and common pitfalls',
+        },
+        tutorial: {
+            title: 'Build an agent from scratch (offline tutorial)',
+            body: spaceTrim$1(`
+                This tutorial is sufficient without internet access.
+
+                1. **Define role and goal**
+                Create a short name line and one clear \`GOAL\`.
+                2. **Add behavioral constraints**
+                Add 3-6 specific \`RULE\` commitments covering scope, tone, and safety boundaries.
+                3. **Add grounding**
+                Add \`KNOWLEDGE\` commitments (inline text or local/importable sources).
+                4. **Add capabilities**
+                Add only necessary \`USE*\` and/or \`MEMORY\` commitments.
+                5. **Set profile metadata**
+                Add \`META DESCRIPTION\`, \`META AVATAR\` / \`META VISUAL\` or \`META IMAGE\`, \`META INPUT PLACEHOLDER\`, \`META THINKING MESSAGE\`, and disclaimers if needed.
+                6. **Add first interaction**
+                Add \`INITIAL MESSAGE\` and optionally sample \`USER MESSAGE\` / \`AGENT MESSAGE\` pairs.
+                7. **Close for deterministic behavior (optional)**
+                Add \`CLOSED\` when you want stable non-self-modifying behavior.
+            `),
+        },
+        lowLevelCommitments: {
+            title: 'Low level commitments',
+            body: spaceTrim$1(`
+                The commitments below are fully part of Book language, but they are intended for advanced use only.
+                Most agents never need them, and using them incorrectly makes an agent harder to maintain.
+
+                Reach for them only when a specific technical requirement cannot be expressed with the commitments above.
+            `),
+        },
+    },
+    mentalModelSections: {
+        detectedIntro: 'Agent composition commitments in current runtime:',
+        detectedProfileLabel: 'Profile-centric commitments detected',
+        detectedBehaviorLabel: 'Behavior-centric commitments detected',
+        detectedToolingLabel: 'Tool/runtime commitments detected',
+        detectedCompositionLabel: 'Composition commitments detected',
+        meta: {
+            title: 'META commitments and agent profile',
+            body: spaceTrim$1(`
+                \`META*\` commitments control profile data shown in UI (for example avatar visual, image, description, disclaimers, domain, input placeholder).
+                They generally shape presentation/metadata rather than tool behavior.
+            `),
+        },
+        inheritance: {
+            title: 'FROM inheritance',
+            body: spaceTrim$1(`
+                \`FROM\` points to a parent agent source. During inheritance resolution:
+
+                - Parent corpus is merged into effective source.
+                - \`FROM {Void}\` / \`FROM VOID\` means explicit "no parent".
+                - Missing references are surfaced as notes in resolved source.
+            `),
+        },
+        composition: {
+            title: 'TEAM and IMPORT',
+            body: spaceTrim$1(`
+                - \`TEAM\` registers teammate agents as callable tools.
+                - \`IMPORT\` injects imported agent/file content into current agent context.
+                - In Agents Server, compact references like \`{Legal Reviewer}\` can resolve to embedded in-book agents.
+            `),
+        },
+        capabilities: {
+            title: 'USE commitments',
+            body: spaceTrim$1(`
+                \`USE*\` commitments enable capabilities (search, browser, project integration, email, image generation, etc.).
+                They expose runtime tools and system-message guidance used during execution.
+            `),
+        },
+    },
+    primitivesSections: {
+        coreSyntax: {
+            title: 'Core syntax primitives',
+            body: spaceTrim$1(`
+                1. **Agent title**:
+                First non-empty line that is not a commitment keyword.
+                2. **Commitment block**:
+                Starts with a commitment keyword and continues until the next commitment block or separator.
+                3. **Horizontal separator**:
+                Lines like \`---\` split sections; in Agents Server they can delimit embedded in-book agents.
+                4. **Code fences**:
+                Preserved inside commitment content; useful for examples/instructions.
+                5. **Parameters**:
+                Both \`@parameter\` and \`{parameter}\` notations are supported and parsed.
+            `),
+        },
+        references: {
+            title: 'Reference tokens and pseudo-agents',
+            body: spaceTrim$1(`
+                - Compact references like \`{Agent Name}\` are resolved by Agents Server reference resolver.
+                - Pseudo-agent forms (for example \`{User}\`, \`{Void}\`) are supported in relevant commitments.
+                - \`{User}\` is intended for \`TEAM\`; \`{Void}\` is useful for explicit no-parent inheritance.
+            `),
+        },
+        keywordsTitle: 'Commitment keywords currently recognized',
+    },
+    commitmentCatalogTitleSuffixes: {
+        usedFirst: ' (used commitments first)',
+        all: ' (all commitments)',
+    },
+    commitmentLabels: {
+        status: 'Status',
+        aliases: 'Aliases',
+        semantics: 'Semantics',
+        typeSchema: 'Type schema',
+        blockSchema: 'Block schema',
+        lowLevelNotice: 'Low-level commitment',
+        usage: 'Used in selected agents',
+        usageOccurrence: 'occurrence',
+        usageOccurrences: 'occurrences',
+        statusImplemented: 'Implemented',
+        statusPlaceholder: 'Placeholder (not fully implemented)',
+        noAliases: 'None',
+    },
+    exampleLabels: {
+        commitmentsUsed: 'Commitments used',
+        fullSource: 'Full source',
+        goal: 'Goal',
+        walkthrough: 'Walkthrough',
+        noCommitments: 'None',
+    },
+    exampleTexts: {
+        'minimal-hello-world-agent': {
+            title: 'Minimal hello-world agent',
+            goal: 'Create the smallest useful agent with identity and greeting.',
+            walkthrough: [
+                'The first line (`Hello World Agent`) is the agent name.',
+                '`GOAL` defines the effective role and profile text.',
+                '`INITIAL MESSAGE` sets a deterministic first message for a new chat.',
+                '`CLOSED` prevents conversational self-modification.',
+            ],
+        },
+        'tool-using-browser-search-agent': {
+            title: 'Tool-using agent (Browser + Search engine)',
+            goal: 'Enable internet research with clear sourcing behavior.',
+            walkthrough: [
+                '`USE SEARCH ENGINE` provides web search tooling and optional search instructions.',
+                '`USE BROWSER` enables URL fetching and interactive browsing tools.',
+                '`RULE` commitments make reliability behavior explicit and repeatable.',
+                'This pattern is ideal for current-events and fact-checking agents.',
+            ],
+        },
+        'rule-and-knowledge-agent': {
+            title: 'Agent with RULE and KNOWLEDGE',
+            goal: 'Ground responses in explicit constraints and curated sources.',
+            walkthrough: [
+                '`KNOWLEDGE` may be inline text or an external URL/document.',
+                '`RULE` commitments define non-negotiable behavior constraints.',
+                'Combining both creates predictable, grounded policy responses.',
+                'Use this pattern for compliance, support, and internal procedures.',
+            ],
+        },
+        'memory-agent-with-long-term-memory': {
+            title: 'MEMORY agent with long-term memory',
+            goal: 'Persist user preferences across conversations.',
+            walkthrough: [
+                '`MEMORY` adds runtime memory tools and memory-specific system guidance.',
+                '`RULE` commitments narrow what should be remembered to reduce privacy risks.',
+                'In Agents Server, memory is runtime-backed and user-scoped.',
+                'Use this for assistants that must preserve context over time.',
+            ],
+        },
+        'use-project-and-wallet-integration-agent': {
+            title: 'USE PROJECT and WALLET external integration',
+            goal: 'Work with GitHub repositories and wallet-backed credentials.',
+            walkthrough: [
+                '`USE PROJECT` enables repository tools for listing, reading, editing files, and creating PRs.',
+                'Credentials are resolved from wallet records at runtime in Agents Server.',
+                '`WALLET` is kept here as a compatibility marker, but current Book 2.0 parsing treats it as ignored.',
+                'In current runtime behavior, wallet-backed integrations are driven by commitments such as `USE PROJECT` and `USE EMAIL`.',
+            ],
+        },
+        'use-calendar-integration-agent': {
+            title: 'USE CALENDAR integration',
+            goal: 'Coordinate meetings and schedules through a connected Google Calendar.',
+            walkthrough: [
+                '`USE CALENDAR` enables calendar tools for listing, reading, creating, updating, and deleting events.',
+                'The first calendar URL identifies which calendar integration should be used.',
+                '`SCOPES` can explicitly request required Google Calendar OAuth permissions.',
+                'Credentials are resolved from wallet-backed Google Calendar OAuth records at runtime in Agents Server.',
+            ],
+        },
+        'agents-team-example': {
+            title: 'Agents TEAM (with in-book teammates)',
+            goal: 'Delegate sub-tasks to specialized teammates.',
+            walkthrough: [
+                'The main agent delegates via `TEAM` commitment.',
+                'References in `{...}` are resolved against embedded agents inside the same book (split by `---`).',
+                'Each teammate can be isolated with `FROM VOID` for deterministic specialization.',
+                'This pattern works well for multi-role review and decision support.',
+            ],
+        },
+    },
+    pitfallLabels: {
+        dont: "Don't",
+        doInstead: 'Do instead',
+    },
+    pitfalls: [
+        {
+            title: 'Too broad agent scope',
+            dont: 'One agent tries to be a lawyer, developer, marketer, and researcher at once.',
+            doInstead: 'Split into focused agents and orchestrate with TEAM or IMPORT.',
+        },
+        {
+            title: 'Unverifiable claims',
+            dont: 'The agent answers internet-dependent questions without tools or without citing sources.',
+            doInstead: 'Add `USE SEARCH ENGINE` / `USE BROWSER` and a citation-oriented `RULE`.',
+        },
+        {
+            title: 'Missing guardrails',
+            dont: 'Only the agent goal is defined, with no behavioral constraints.',
+            doInstead: 'Add concrete `RULE` commitments for safety, scope, and tone.',
+        },
+        {
+            title: 'Overloaded inheritance',
+            dont: 'Using deep `FROM` chains without documenting why each parent is needed.',
+            doInstead: 'Keep inheritance shallow and use focused IMPORT/TEAM composition for reuse.',
+        },
+        {
+            title: 'Unsafe memory usage',
+            dont: 'Storing every detail in memory without boundaries.',
+            doInstead: 'Pair `MEMORY` with explicit rules about what is allowed to persist.',
+        },
+    ],
+    tutorialSections: {
+        serverAgentsHint: 'Use one of the selected server-agent examples above as your starting point, then retain only the commitments needed for the new agent.',
+        templateIntro: 'Copy-paste template:',
+        checklistTitle: 'Validation checklist:',
+        checklistBody: spaceTrim$1(`
+            - Does each commitment have a clear purpose?
+            - Are there explicit constraints against hallucination and unsafe behavior?
+            - Are tools only enabled when genuinely needed?
+            - Is memory usage bounded by clear rules?
+            - Is composition (\`FROM\`/\`TEAM\`/\`IMPORT\`) justified and understandable?
+        `),
+    },
+    footer: {
+        title: 'Generated from:',
+        body: spaceTrim$1(`
+            - Commitments registry and runtime docs in \`src/commitments\`
+            - Parser/compiler behavior in \`src/book-2.0/agent-source\`
+            - Agents Server reference/inheritance resolution in \`apps/agents-server/src/utils\`
+            - Standalone docs source blocks in \`apps/agents-server/src/utils/bookLanguageDocumentation\`
+        `),
+    },
+};
+
+/**
+ * All language packs of the standalone Book language manual.
+ *
+ * Add a new dictionary here to make the manual exportable in one more language.
+ *
+ * @private internal constant of `createStandaloneBookLanguageMarkdown`
+ */
+const BOOK_LANGUAGE_MANUAL_DICTIONARIES = [
+    englishBookLanguageManualDictionary,
+    czechBookLanguageManualDictionary,
+];
+/**
+ * Resolves the manual dictionary for one requested language.
+ *
+ * Unknown and region-qualified codes (for example `cs-CZ`) fall back to the
+ * closest available pack and finally to English, so an export never fails
+ * because of an unsupported language.
+ *
+ * @param language - Requested language code.
+ * @returns Manual dictionary for the requested language or the English fallback.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function getBookLanguageManualDictionary(language) {
+    const normalizedLanguage = (language || '').trim().toLowerCase().split(/[-_]/)[0];
+    return (BOOK_LANGUAGE_MANUAL_DICTIONARIES.find((dictionary) => dictionary.language === normalizedLanguage) ||
+        englishBookLanguageManualDictionary);
+}
+
+/**
+ * Creates a safe markdown fenced code block even when content contains backticks.
+ *
+ * @param content - Raw code content.
+ * @param language - Optional info-string language label.
+ * @returns Fenced code block.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function getSafeCodeBlock(content, language = 'markdown') {
+    const maxBacktickCount = Math.max(0, ...(content.match(/`+/g) || []).map((match) => match.length));
+    const fence = '`'.repeat(Math.max(3, maxBacktickCount + 1));
+    return `${fence}${language}\n${content}\n${fence}`;
+}
+
+/**
+ * Deepest heading level markdown supports.
+ *
+ * @private internal constant of `shiftMarkdownHeadingLevels`
+ */
+const MAX_MARKDOWN_HEADING_LEVEL = 6;
+/**
+ * Matches one ATX heading at the beginning of a line.
+ *
+ * @private internal constant of `shiftMarkdownHeadingLevels`
+ */
+const MARKDOWN_HEADING_REGEX = /^(#{1,6})(\s)/;
+/**
+ * Matches a fenced code-block delimiter.
+ *
+ * @private internal constant of `shiftMarkdownHeadingLevels`
+ */
+const MARKDOWN_CODE_FENCE_REGEX = /^\s*(```|~~~)/;
+/**
+ * Moves every heading of a markdown document deeper into the hierarchy.
+ *
+ * This is needed when an independent markdown document is embedded under an
+ * existing heading, so that the merged document keeps one consistent outline.
+ * Headings inside fenced code blocks are left untouched.
+ *
+ * @param markdown - Markdown document to shift.
+ * @param headingLevelShift - How many levels the headings should move down.
+ * @returns Markdown with shifted headings.
+ *
+ * @private internal utility for composing markdown documents
+ */
+function shiftMarkdownHeadingLevels(markdown, headingLevelShift) {
+    if (headingLevelShift <= 0) {
+        return markdown;
+    }
+    let isInsideCodeBlock = false;
+    return markdown
+        .split('\n')
+        .map((line) => {
+        if (MARKDOWN_CODE_FENCE_REGEX.test(line)) {
+            isInsideCodeBlock = !isInsideCodeBlock;
+            return line;
+        }
+        if (isInsideCodeBlock) {
+            return line;
+        }
+        return line.replace(MARKDOWN_HEADING_REGEX, (_match, headingPrefix, whitespace) => {
+            const shiftedLevel = Math.min(headingPrefix.length + headingLevelShift, MAX_MARKDOWN_HEADING_LEVEL);
+            return `${'#'.repeat(shiftedLevel)}${whitespace}`;
+        });
+    })
+        .join('\n');
+}
+
+/**
+ * Canonical commitment keyword for the open/closed family.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+const OPEN_COMMITMENT_TYPE = 'OPEN';
+/**
+ * Canonical commitment keyword for the open/closed family.
+ */
+const CLOSED_COMMITMENT_TYPE = 'CLOSED';
+/**
+ * Heading level of the sections a commitment documentation body starts with.
+ *
+ * Every commitment body opens with `# TYPE` followed by `##` sections, so a
+ * family subsection heading has to sit exactly one level above those sections.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+const COMMITMENT_DOCUMENTATION_SECTION_HEADING_LEVEL = 2;
+/**
+ * Removes the top-level heading from one commitment documentation block.
+ *
+ * @param markdown - Original markdown source.
+ * @returns Markdown without the first `#` heading.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function removeLeadingTopLevelHeading(markdown) {
+    return markdown.replace(/^\s*#\s+[^\n]+\n*/u, '').trim();
+}
+/**
+ * Renders one subsection for the combined open/closed documentation family.
+ *
+ * @param title - Heading label for the subsection.
+ * @param documentation - Raw commitment documentation markdown.
+ * @param headingLevelShift - How many levels the whole entry is nested by its host document.
+ * @returns Markdown subsection introducing one commitment of the family.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderDocumentationSection(title, documentation, headingLevelShift) {
+    const headingPrefix = '#'.repeat(COMMITMENT_DOCUMENTATION_SECTION_HEADING_LEVEL + headingLevelShift);
+    return spaceTrim$1((block) => `
+            ${headingPrefix} ${title}
+
+            ${block(shiftMarkdownHeadingLevels(removeLeadingTopLevelHeading(documentation), headingLevelShift + 1))}
+        `);
+}
+/**
+ * Renders the documentation body for one grouped commitment entry.
+ *
+ * `OPEN` and `CLOSED` are intentionally rendered together so the documentation
+ * surfaces present them as one conceptual switch instead of two isolated pages.
+ *
+ * @param group - Grouped commitment metadata.
+ * @param headingLevelShift - How many levels the entry is nested by its host document.
+ * @returns Markdown body for the docs page/catalog entry.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderGroupedCommitmentDocumentationMarkdown(group, headingLevelShift = 0) {
+    const commitmentTypes = new Set([group.primary.type, ...group.aliases]);
+    if (commitmentTypes.has(OPEN_COMMITMENT_TYPE) && commitmentTypes.has(CLOSED_COMMITMENT_TYPE)) {
+        const openCommitmentDefinition = getCommitmentDefinition(OPEN_COMMITMENT_TYPE);
+        const closedCommitmentDefinition = getCommitmentDefinition(CLOSED_COMMITMENT_TYPE);
+        if (openCommitmentDefinition && closedCommitmentDefinition) {
+            return spaceTrim$1((block) => `
+                    ${block(renderDocumentationSection(OPEN_COMMITMENT_TYPE, openCommitmentDefinition.documentation, headingLevelShift))}
+
+                    ${block(renderDocumentationSection(CLOSED_COMMITMENT_TYPE, closedCommitmentDefinition.documentation, headingLevelShift))}
+                `);
+        }
+    }
+    return shiftMarkdownHeadingLevels(removeLeadingTopLevelHeading(group.primary.documentation), headingLevelShift);
+}
+
+/**
+ * Converts a heading label into a stable markdown anchor id.
+ *
+ * Anchors are generated from language-neutral identifiers, so deep links into
+ * the manual keep working in every translation.
+ *
+ * @param value - Raw heading/identifier text.
+ * @returns Stable lowercase anchor id.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function toStableAnchorId(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * How deep one commitment documentation body is nested inside the catalog.
+ *
+ * A catalog entry is a `###` heading, therefore the `##` sections of the
+ * commitment documentation have to become `####` sections.
+ *
+ * @private internal constant of `renderCommitmentCatalogSection`
+ */
+const COMMITMENT_CATALOG_HEADING_LEVEL_SHIFT = 2;
+/**
+ * Renders one commitment section in the generated catalog.
+ *
+ * @param options - Commitment group, usage statistics, and translated labels.
+ * @returns Markdown section for a single commitment.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderCommitmentCatalogSection(options) {
+    var _a;
+    const { groupedCommitment, usageCount, dictionary } = options;
+    const { primary, aliases } = groupedCommitment;
+    const labels = dictionary.commitmentLabels;
+    const notice = getCommitmentNoticeMetadata(primary);
+    const status = primary instanceof NotYetImplementedCommitmentDefinition
+        ? labels.statusPlaceholder
+        : notice
+            ? `${labels.statusImplemented} (${notice.detailLabel})`
+            : labels.statusImplemented;
+    const aliasText = aliases.length === 0 ? labels.noAliases : aliases.map((alias) => `\`${alias}\``).join(', ');
+    const noticeText = notice
+        ? notice.kind === 'deprecated'
+            ? `- **${notice.detailLabel}:** ${notice.message}${formatCommitmentReplacementText((_a = primary.deprecation) === null || _a === void 0 ? void 0 : _a.replacedBy)}`
+            : `- **${labels.lowLevelNotice}:** ${notice.message}`
+        : '';
+    const usageMarkdown = usageCount > 0
+        ? `- **${labels.usage}:** ${usageCount} ${usageCount === 1 ? labels.usageOccurrence : labels.usageOccurrences}`
+        : '';
+    return spaceTrim$1((block) => `
+            ### <a id="commitment-${toStableAnchorId(primary.type)}"></a>${primary.icon} ${primary.type}
+
+            - **${labels.status}:** ${status}
+            - **${labels.aliases}:** ${aliasText}
+            - **${labels.semantics}:** ${primary.description}
+            - **${labels.typeSchema} (\`createTypeRegex\`):** \`${stringifyRegex(primary.createTypeRegex())}\`
+            - **${labels.blockSchema} (\`createRegex\`):** \`${stringifyRegex(primary.createRegex())}\`
+            ${noticeText}
+            ${usageMarkdown}
+
+            ${block(renderGroupedCommitmentDocumentationMarkdown(groupedCommitment, COMMITMENT_CATALOG_HEADING_LEVEL_SHIFT))}
+        `);
+}
+/**
+ * Converts a regular expression into a concise literal-like string.
+ *
+ * @param regex - Regex instance.
+ * @returns Printable regex pattern and flags.
+ *
+ * @private internal utility of `renderCommitmentCatalogSection`
+ */
+function stringifyRegex(regex) {
+    return `/${regex.source}/${regex.flags}`;
+}
+
+/**
+ * Commitment types that primarily model composition of multiple agents.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+const COMPOSITION_COMMITMENT_TYPES = new Set(['FROM', 'IMPORT', 'IMPORTS', 'TEAM']);
 /**
  * Commitment types that expose tools/runtime capabilities.
  *
@@ -29915,8 +30828,6 @@ const TOOLING_COMMITMENT_TYPES = new Set([
 const PROFILE_COMMITMENT_TYPES = new Set([
     'GOAL',
     'GOALS',
-    'PERSONA',
-    'PERSONAE',
     'META',
     'META AVATAR',
     'META VISUAL',
@@ -29926,13 +30837,12 @@ const PROFILE_COMMITMENT_TYPES = new Set([
     'META DESCRIPTION',
     'META DISCLAIMER',
     'META INPUT PLACEHOLDER',
+    'META THINKING MESSAGE',
     'META VISIBILITY',
     'META COLOR',
     'META FONT',
     'META VOICE',
     'INITIAL MESSAGE',
-    'MODEL',
-    'MODELS',
 ]);
 /**
  * Commitment types that primarily define behavioral constraints or prompt shaping.
@@ -29945,18 +30855,10 @@ const BEHAVIOR_COMMITMENT_TYPES = new Set([
     'KNOWLEDGE',
     'GOAL',
     'GOALS',
-    'STYLE',
-    'STYLES',
     'LANGUAGE',
     'LANGUAGES',
-    'FORMAT',
-    'FORMATS',
-    'TEMPLATE',
-    'TEMPLATES',
     'WRITING SAMPLE',
     'WRITING RULES',
-    'SAMPLE',
-    'EXAMPLE',
     'SCENARIO',
     'SCENARIOS',
     'MESSAGE',
@@ -29980,212 +30882,233 @@ const BEHAVIOR_COMMITMENT_TYPES = new Set([
  *
  * @public exported from `@promptbook/core`
  */
-function createStandaloneBookLanguageMarkdown() {
-    const groupedCommitments = getGroupedCommitmentDefinitions();
+function createStandaloneBookLanguageMarkdown(options = {}) {
+    var _a;
+    const dictionary = getBookLanguageManualDictionary(options.language);
+    const { documented, lowLevel } = getBookLanguageManualCommitmentGroups();
+    const selectedAgents = ((_a = options.agents) === null || _a === void 0 ? void 0 : _a.filter((agent) => agent.agentSource.trim().length > 0)) || [];
+    const commitmentUsageByType = createCommitmentUsageByType(selectedAgents);
+    const isServerSpecificManual = selectedAgents.length > 0;
+    const isLowLevelCommitmentsIncluded = options.isLowLevelCommitmentsIncluded === true;
+    const catalogCommitments = prioritizeGroupedCommitments(documented, commitmentUsageByType);
+    const lowLevelCommitments = isLowLevelCommitmentsIncluded
+        ? prioritizeGroupedCommitments(lowLevel, commitmentUsageByType)
+        : [];
+    const manualCommitments = [...catalogCommitments, ...lowLevelCommitments];
     const generatedAtIso = new Date().toISOString();
-    const placeholderCommitmentCount = groupedCommitments.filter(({ primary }) => primary instanceof NotYetImplementedCommitmentDefinition).length;
-    const implementedCommitmentCount = groupedCommitments.length - placeholderCommitmentCount;
-    const allCommitmentKeywords = groupedCommitments.flatMap(({ primary, aliases }) => [primary.type, ...aliases]);
-    const toolingCommitments = groupedCommitments.filter(({ primary }) => TOOLING_COMMITMENT_TYPES.has(primary.type));
-    const profileCommitments = groupedCommitments.filter(({ primary }) => PROFILE_COMMITMENT_TYPES.has(primary.type));
-    const compositionCommitments = groupedCommitments.filter(({ primary }) => COMPOSITION_COMMITMENT_TYPES.has(primary.type));
-    const behaviorCommitments = groupedCommitments.filter(({ primary }) => BEHAVIOR_COMMITMENT_TYPES.has(primary.type));
+    const placeholderCommitmentCount = manualCommitments.filter(({ primary }) => primary instanceof NotYetImplementedCommitmentDefinition).length;
+    const catalogTitleSuffix = isServerSpecificManual
+        ? dictionary.commitmentCatalogTitleSuffixes.usedFirst
+        : dictionary.commitmentCatalogTitleSuffixes.all;
+    const allCommitmentKeywords = manualCommitments.flatMap(({ primary, aliases }) => [primary.type, ...aliases]);
     return spaceTrim$1(
     // [✨]
     (block) => `
-            # Book Language blueprint
-
-            > Canonical standalone guide for Promptbook Book Agent language.  
-            > Generated from repository https://github.com/webgptorg/promptbook
+            # ${dictionary.title}
 
-            - Book language version: \`${BOOK_LANGUAGE_VERSION}\`
-            - Generated at: \`${generatedAtIso}\`
-            - Commitment groups: \`${groupedCommitments.length}\`
-            - Implemented commitments: \`${implementedCommitmentCount}\`
-            - Placeholder commitments: \`${placeholderCommitmentCount}\`
+            ${block(dictionary.introLines.map((introLine) => `> ${introLine}  `).join('\n'))}
 
-            ## <a id="table-of-contents"></a>Table of Contents
+            - ${dictionary.metadataLabels.bookLanguageVersion}: \`${BOOK_LANGUAGE_VERSION}\`
+            - ${dictionary.metadataLabels.generatedAt}: \`${generatedAtIso}\`
+            - ${dictionary.metadataLabels.commitmentGroups}: \`${manualCommitments.length}\`
+            - ${dictionary.metadataLabels.implementedCommitments}: \`${manualCommitments.length - placeholderCommitmentCount}\`
+            - ${dictionary.metadataLabels.placeholderCommitments}: \`${placeholderCommitmentCount}\`
 
-            - [What Book language is](#what-book-language-is)
-            - [Execution and compilation model](#execution-and-compilation-model)
-            - [Mental model of an agent](#mental-model-of-an-agent)
-            - [How to structure good agents](#how-to-structure-good-agents)
-            - [Primitives and constructs reference](#primitives-and-constructs-reference)
-            - [Commitment catalog (all commitments)](#commitment-catalog-all-commitments)
-            - [End-to-end examples](#end-to-end-examples)
-            - [Do nots and common pitfalls](#do-nots-and-common-pitfalls)
-            - [Build an agent from scratch (offline tutorial)](#build-an-agent-from-scratch-offline-tutorial)
+            ## <a id="table-of-contents"></a>${dictionary.tableOfContentsTitle}
 
-            ## <a id="what-book-language-is"></a>What Book language is
+            - [${dictionary.chapters.whatIs.title}](#what-book-language-is)
+            - [${dictionary.chapters.mentalModel.title}](#mental-model-of-an-agent)
+            - [${dictionary.chapters.howToStructure.title}](#how-to-structure-good-agents)
+            - [${dictionary.chapters.primitives.title}](#primitives-and-constructs-reference)
+            - [${dictionary.chapters.commitmentCatalog.title}${catalogTitleSuffix}](#commitment-catalog)
+            - [${dictionary.chapters.examples.title}](#end-to-end-examples)
+            - [${dictionary.chapters.pitfalls.title}](#do-nots-and-common-pitfalls)
+            - [${dictionary.chapters.tutorial.title}](#build-an-agent-from-scratch-offline-tutorial)
+            ${isLowLevelCommitmentsIncluded
+        ? `- [${dictionary.chapters.lowLevelCommitments.title}](#low-level-commitments)`
+        : ''}
 
-            Book language is a domain-specific language for defining **AI agents** as plain-text source.
-            It solves these problems:
+            ## <a id="what-book-language-is"></a>${dictionary.chapters.whatIs.title}
 
-            - **One editable source of truth** for agent behavior, tools, memory, and profile metadata.
-            - **Composable agent architecture** through commitments like \`FROM\`, \`IMPORT\`, and \`TEAM\`.
-            - **Deterministic runtime preparation** where source is parsed and compiled into model requirements.
-            - **Portable agent definitions** that can be copied, versioned, and reviewed as text.
+            ${block(dictionary.chapters.whatIs.body)}
 
-            In this repository, "Book language" means **Book 2.0 agent language**.
+            ## <a id="mental-model-of-an-agent"></a>${dictionary.chapters.mentalModel.title}
 
-            ## <a id="execution-and-compilation-model"></a>Execution and compilation model
-
-            Promptbook and Agents Server use two core passes:
+            ${block(dictionary.chapters.mentalModel.body)}
 
-            1. **Fast parse pass** (\`parseAgentSource\`):
-            It synchronously extracts agent profile/basic info (name, last goal/profile text, meta, capabilities, samples, references).
-            2. **Compilation pass** (\`createAgentModelRequirements\`):
-            It applies commitments in sequence and builds executable model requirements (system message, tools, memory/tool metadata, imports, etc.).
+            ${dictionary.mentalModelSections.detectedIntro}
 
-            In Agents Server, the runtime flow typically includes:
+            ${block(renderDetectedCommitmentList(catalogCommitments, dictionary))}
 
-            1. Resolve scoped references (including in-book references like \`{Some Agent}\`).
-            2. Resolve inheritance/import chains into effective source.
-            3. Compile effective source into model requirements.
-            4. Execute chat turns with resolved tools and runtime adapters.
+            ### ${dictionary.mentalModelSections.meta.title}
 
-            ## <a id="mental-model-of-an-agent"></a>Mental model of an agent
+            ${block(dictionary.mentalModelSections.meta.body)}
 
-            Think of one agent source as four layers:
+            ### ${dictionary.mentalModelSections.inheritance.title}
 
-            1. **Identity/Profile layer**:
-            Agent name (first non-commitment line), the last \`GOAL\` (preferred) or deprecated \`PERSONA\`, and \`META*\` commitments.
-            2. **Behavior layer**:
-            \`RULE\`, \`KNOWLEDGE\`, \`WRITING SAMPLE\`, \`WRITING RULES\`, deprecated \`STYLE\`, \`FORMAT\`, \`TEMPLATE\`, \`LANGUAGE\`, \`GOAL\`, and related commitments.
-            3. **Capability layer**:
-            \`USE*\`, \`MEMORY\`, and other tooling commitments exposing runtime abilities.
-            4. **Composition layer**:
-            \`FROM\` inheritance, \`IMPORT\` reuse, and \`TEAM\` delegation.
+            ${block(dictionary.mentalModelSections.inheritance.body)}
 
-            Agent composition commitments in current runtime:
+            ### ${dictionary.mentalModelSections.composition.title}
 
-            - Profile-centric commitments detected: ${profileCommitments
-        .map(({ primary }) => `\`${primary.type}\``)
-        .join(', ')}
-            - Behavior-centric commitments detected: ${behaviorCommitments
-        .map(({ primary }) => `\`${primary.type}\``)
-        .join(', ')}
-            - Tool/runtime commitments detected: ${toolingCommitments
-        .map(({ primary }) => `\`${primary.type}\``)
-        .join(', ')}
-            - Composition commitments detected: ${compositionCommitments
-        .map(({ primary }) => `\`${primary.type}\``)
-        .join(', ')}
+            ${block(dictionary.mentalModelSections.composition.body)}
 
-            ### META commitments and agent profile
+            ### ${dictionary.mentalModelSections.capabilities.title}
 
-            \`META*\` commitments control profile data shown in UI (for example avatar visual, image, description, disclaimers, domain, input placeholder).
-            They generally shape presentation/metadata rather than tool behavior.
+            ${block(dictionary.mentalModelSections.capabilities.body)}
 
-            ### FROM inheritance
+            ## <a id="how-to-structure-good-agents"></a>${dictionary.chapters.howToStructure.title}
 
-            \`FROM\` points to a parent agent source. During inheritance resolution:
+            ${block(dictionary.chapters.howToStructure.body)}
 
-            - Parent corpus is merged into effective source.
-            - \`FROM {Void}\` / \`FROM VOID\` means explicit "no parent".
-            - Missing references are surfaced as notes in resolved source.
+            ## <a id="primitives-and-constructs-reference"></a>${dictionary.chapters.primitives.title}
 
-            ### TEAM and IMPORT
+            ### ${dictionary.primitivesSections.coreSyntax.title}
 
-            - \`TEAM\` registers teammate agents as callable tools.
-            - \`IMPORT\` injects imported agent/file content into current agent context.
-            - In Agents Server, compact references like \`{Legal Reviewer}\` can resolve to embedded in-book agents.
+            ${block(dictionary.primitivesSections.coreSyntax.body)}
 
-            ### USE commitments
+            ### ${dictionary.primitivesSections.references.title}
 
-            \`USE*\` commitments enable capabilities (search, browser, project integration, email, image generation, etc.).
-            They expose runtime tools and system-message guidance used during execution.
+            ${block(dictionary.primitivesSections.references.body)}
 
-            ## <a id="how-to-structure-good-agents"></a>How to structure good agents
+            ### ${dictionary.primitivesSections.keywordsTitle}
 
-            Recommended patterns and tradeoffs:
-
-            1. **Single clear role first**:
-            Start with one narrow \`GOAL\`; use \`PERSONA\` only for backward-compatible legacy books.
-            Tradeoff: less initial flexibility, much higher reliability.
-            2. **Guardrails early**:
-            Add concrete \`RULE\` commitments before adding many tools.
-            Tradeoff: more upfront design, fewer runtime surprises.
-            3. **Grounding over improvisation**:
-            Prefer \`KNOWLEDGE\` + explicit citation rule for high-stakes answers.
-            Tradeoff: extra maintenance for sources, better factual control.
-            4. **Composition over monoliths**:
-            Use \`TEAM\`/\`IMPORT\` for specialized responsibilities.
-            Tradeoff: orchestration overhead, stronger modularity and reuse.
-            5. **Controlled memory**:
-            If using \`MEMORY\`, define what must and must not be remembered.
-            Tradeoff: stricter policy design, better privacy and signal quality.
+            ${block(getSafeCodeBlock(allCommitmentKeywords.join(', '), 'text'))}
 
-            ## <a id="primitives-and-constructs-reference"></a>Primitives and constructs reference
+            <a id="commitment-catalog-all-commitments"></a>
 
-            ### Core syntax primitives
+            ## <a id="commitment-catalog"></a>${dictionary.chapters.commitmentCatalog.title}${catalogTitleSuffix}
 
-            1. **Agent title**:
-            First non-empty line that is not a commitment keyword.
-            2. **Commitment block**:
-            Starts with a commitment keyword and continues until the next commitment block or separator.
-            3. **Horizontal separator**:
-            Lines like \`---\` split sections; in Agents Server they can delimit embedded in-book agents.
-            4. **Code fences**:
-            Preserved inside commitment content; useful for examples/instructions.
-            5. **Parameters**:
-            Both \`@parameter\` and \`{parameter}\` notations are supported and parsed.
+            ${block(dictionary.chapters.commitmentCatalog.body)}
 
-            ### Reference tokens and pseudo-agents
+            ${block(renderCommitmentCatalogSections(catalogCommitments, commitmentUsageByType, dictionary))}
 
-            - Compact references like \`{Agent Name}\` are resolved by Agents Server reference resolver.
-            - Pseudo-agent forms (for example \`{User}\`, \`{Void}\`) are supported in relevant commitments.
-            - \`{User}\` is intended for \`TEAM\`; \`{Void}\` is useful for explicit no-parent inheritance.
+            ## <a id="end-to-end-examples"></a>${dictionary.chapters.examples.title}
 
-            ### Commitment keywords currently recognized
+            ${block(isServerSpecificManual
+        ? selectedAgents.map((agent) => renderBakedAgentExampleSection(agent, dictionary)).join('\n\n')
+        : bookLanguageDocumentationExamples
+            .map((example) => renderExampleSection(example, dictionary))
+            .join('\n\n'))}
 
-            ${block(getSafeCodeBlock(allCommitmentKeywords.join(', '), 'text'))}
+            ## <a id="do-nots-and-common-pitfalls"></a>${dictionary.chapters.pitfalls.title}
 
-            ## <a id="commitment-catalog-all-commitments"></a>Commitment catalog (all commitments)
+            ${block(renderPitfallList(dictionary))}
 
-            This section is generated from commitment definitions in \`src/commitments\`.
-            For each commitment group you get:
+            ## <a id="build-an-agent-from-scratch-offline-tutorial"></a>${dictionary.chapters.tutorial.title}
 
-            - semantics summary (description/icon/status)
-            - parsing schema (\`createTypeRegex\` and \`createRegex\`)
-            - canonical documentation block
+            ${block(dictionary.chapters.tutorial.body)}
 
-            ${block(groupedCommitments.map(renderCommitmentCatalogSection).join('\n\n'))}
+            ${block(isServerSpecificManual
+        ? dictionary.tutorialSections.serverAgentsHint
+        : renderCopyPasteTemplate(dictionary))}
 
-            ## <a id="end-to-end-examples"></a>End-to-end examples
+            ${dictionary.tutorialSections.checklistTitle}
 
-            ${block(bookLanguageDocumentationExamples.map(renderExampleSection).join('\n\n'))}
+            ${block(dictionary.tutorialSections.checklistBody)}
 
-            ## <a id="do-nots-and-common-pitfalls"></a>Do nots and common pitfalls
+            ${block(isLowLevelCommitmentsIncluded
+        ? renderLowLevelCommitmentsChapter(lowLevelCommitments, commitmentUsageByType, dictionary)
+        : '')}
 
-            ${block(bookLanguageCommonPitfalls
-        .map((pitfall, index) => spaceTrim$1(`
-                            ${index + 1}. **${pitfall.title}**
-                            - Don't: ${pitfall.dont}
-                            - Do instead: ${pitfall.doInstead}
-                        `))
-        .join('\n'))}
+            ---
 
-            ## <a id="build-an-agent-from-scratch-offline-tutorial"></a>Build an agent from scratch (offline tutorial)
+            ${dictionary.footer.title}
 
-            This tutorial is sufficient without internet access.
+            ${block(dictionary.footer.body)}
+        `);
+}
+/**
+ * Renders the bullet list summarizing which commitment kinds the runtime exposes.
+ *
+ * @param commitmentGroups - Commitment groups documented in the main catalog.
+ * @param dictionary - Translated labels of the manual.
+ * @returns Markdown bullet list of detected commitment kinds.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderDetectedCommitmentList(commitmentGroups, dictionary) {
+    const detectedSections = [
+        { label: dictionary.mentalModelSections.detectedProfileLabel, types: PROFILE_COMMITMENT_TYPES },
+        { label: dictionary.mentalModelSections.detectedBehaviorLabel, types: BEHAVIOR_COMMITMENT_TYPES },
+        { label: dictionary.mentalModelSections.detectedToolingLabel, types: TOOLING_COMMITMENT_TYPES },
+        { label: dictionary.mentalModelSections.detectedCompositionLabel, types: COMPOSITION_COMMITMENT_TYPES },
+    ];
+    return detectedSections
+        .map(({ label, types }) => {
+        const detectedTypes = commitmentGroups
+            .filter(({ primary }) => types.has(primary.type))
+            .map(({ primary }) => `\`${primary.type}\``)
+            .join(', ');
+        return `- ${label}: ${detectedTypes}`;
+    })
+        .join('\n');
+}
+/**
+ * Renders every commitment section of one catalog chapter.
+ *
+ * @param commitmentGroups - Commitment groups to render, in final order.
+ * @param commitmentUsageByType - Selected-agent occurrence counts by primary type.
+ * @param dictionary - Translated labels of the manual.
+ * @returns Markdown sections joined by blank lines.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderCommitmentCatalogSections(commitmentGroups, commitmentUsageByType, dictionary) {
+    return commitmentGroups
+        .map((groupedCommitment) => renderCommitmentCatalogSection({
+        groupedCommitment,
+        usageCount: commitmentUsageByType.get(groupedCommitment.primary.type) || 0,
+        dictionary,
+    }))
+        .join('\n\n');
+}
+/**
+ * Renders the closing chapter documenting low-level commitments.
+ *
+ * @param commitmentGroups - Low-level commitment groups, in final order.
+ * @param commitmentUsageByType - Selected-agent occurrence counts by primary type.
+ * @param dictionary - Translated labels of the manual.
+ * @returns Markdown chapter for low-level commitments.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderLowLevelCommitmentsChapter(commitmentGroups, commitmentUsageByType, dictionary) {
+    return spaceTrim$1((block) => `
+            ## <a id="low-level-commitments"></a>${dictionary.chapters.lowLevelCommitments.title}
 
-            1. **Define role and goal**
-            Create a short name line and one clear \`GOAL\`.
-            2. **Add behavioral constraints**
-            Add 3-6 specific \`RULE\` commitments covering scope, tone, and safety boundaries.
-            3. **Add grounding**
-            Add \`KNOWLEDGE\` commitments (inline text or local/importable sources).
-            4. **Add capabilities**
-            Add only necessary \`USE*\` and/or \`MEMORY\` commitments.
-            5. **Set profile metadata**
-            Add \`META DESCRIPTION\`, \`META AVATAR\` / \`META VISUAL\` or \`META IMAGE\`, \`META INPUT PLACEHOLDER\`, and disclaimers if needed.
-            6. **Add first interaction**
-            Add \`INITIAL MESSAGE\` and optionally sample \`USER MESSAGE\` / \`AGENT MESSAGE\` pairs.
-            7. **Close for deterministic behavior (optional)**
-            Add \`CLOSED\` when you want stable non-self-modifying behavior.
+            ${block(dictionary.chapters.lowLevelCommitments.body)}
 
-            Copy-paste template:
+            ${block(renderCommitmentCatalogSections(commitmentGroups, commitmentUsageByType, dictionary))}
+        `);
+}
+/**
+ * Renders the "don't vs do" list of common authoring pitfalls.
+ *
+ * @param dictionary - Translated labels and pitfalls of the manual.
+ * @returns Markdown ordered list of pitfalls.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderPitfallList(dictionary) {
+    return dictionary.pitfalls
+        .map((pitfall, index) => spaceTrim$1(`
+                ${index + 1}. **${pitfall.title}**
+                - ${dictionary.pitfallLabels.dont}: ${pitfall.dont}
+                - ${dictionary.pitfallLabels.doInstead}: ${pitfall.doInstead}
+            `))
+        .join('\n');
+}
+/**
+ * Renders the copy-paste starting template of the offline tutorial.
+ *
+ * @param dictionary - Translated labels of the manual.
+ * @returns Markdown intro sentence with a Book source template.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderCopyPasteTemplate(dictionary) {
+    return spaceTrim$1((block) => `
+            ${dictionary.tutorialSections.templateIntro}
 
             ${block(getSafeCodeBlock(spaceTrim$1(`
                         Project Assistant
@@ -30202,129 +31125,109 @@ function createStandaloneBookLanguageMarkdown() {
 
                         META DESCRIPTION Practical project-planning assistant.
                         META INPUT PLACEHOLDER Describe your project goal or blocker...
+                        META THINKING MESSAGE Reviewing your project details...
 
                         INITIAL MESSAGE Share your project goal and current blocker, and I will propose a concrete next-step plan.
                         CLOSED
                     `), 'book'))}
-
-            Validation checklist:
-
-            - Does each commitment have a clear purpose?
-            - Are there explicit constraints against hallucination and unsafe behavior?
-            - Are tools only enabled when genuinely needed?
-            - Is memory usage bounded by clear rules?
-            - Is composition (\`FROM\`/\`TEAM\`/\`IMPORT\`) justified and understandable?
-
-            ---
-
-            Generated from:
-
-            - Commitments registry and runtime docs in \`src/commitments\`
-            - Parser/compiler behavior in \`src/book-2.0/agent-source\`
-            - Agents Server reference/inheritance resolution in \`apps/agents-server/src/utils\`
-            - Standalone docs source blocks in \`apps/agents-server/src/utils/bookLanguageDocumentation\`
         `);
 }
 /**
- * Renders one commitment section in the generated catalog.
+ * Counts each selected agent's parsed commitments by their canonical group type.
  *
- * @param groupedCommitment - Grouped commitment definition with aliases.
- * @returns Markdown section for a single commitment.
+ * @param agents - Agent sources baked into the manual.
+ * @returns Occurrence counts keyed by primary commitment type.
  *
  * @private internal utility of `createStandaloneBookLanguageMarkdown`
  */
-function renderCommitmentCatalogSection(groupedCommitment) {
-    var _a;
-    const { primary, aliases } = groupedCommitment;
-    const notice = getCommitmentNoticeMetadata(primary);
-    const status = primary instanceof NotYetImplementedCommitmentDefinition
-        ? 'Placeholder (not fully implemented)'
-        : notice
-            ? `Implemented (${notice.detailLabel})`
-            : 'Implemented';
-    const aliasText = aliases.length === 0 ? 'None' : aliases.map((alias) => `\`${alias}\``).join(', ');
-    const noticeText = notice
-        ? notice.kind === 'deprecated'
-            ? `- **Deprecation:** ${notice.message}${formatCommitmentReplacementText((_a = primary.deprecation) === null || _a === void 0 ? void 0 : _a.replacedBy)}`
-            : `- **Low-level commitment:** ${notice.message}`
-        : '';
-    const documentationMarkdown = renderGroupedCommitmentDocumentationMarkdown(groupedCommitment);
+function createCommitmentUsageByType(agents) {
+    const primaryTypeByCommitmentType = new Map();
+    for (const { primary, aliases } of getGroupedCommitmentDefinitions()) {
+        primaryTypeByCommitmentType.set(primary.type, primary.type);
+        for (const alias of aliases) {
+            primaryTypeByCommitmentType.set(alias, primary.type);
+        }
+    }
+    const usageByType = new Map();
+    for (const agent of agents) {
+        for (const commitment of parseAgentSourceWithCommitments(agent.agentSource).commitments) {
+            const primaryType = primaryTypeByCommitmentType.get(commitment.type);
+            if (primaryType) {
+                usageByType.set(primaryType, (usageByType.get(primaryType) || 0) + 1);
+            }
+        }
+    }
+    return usageByType;
+}
+/**
+ * Preserves canonical ordering while moving actually used commitment groups first.
+ *
+ * @param groupedCommitments - Canonically ordered commitment definitions.
+ * @param commitmentUsageByType - Selected-agent occurrence counts by primary type.
+ * @returns Commitment groups sorted by selected-agent usage, then canonical order.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function prioritizeGroupedCommitments(groupedCommitments, commitmentUsageByType) {
+    return groupedCommitments
+        .map((groupedCommitment, index) => ({
+        groupedCommitment,
+        index,
+        usageCount: commitmentUsageByType.get(groupedCommitment.primary.type) || 0,
+    }))
+        .sort((first, second) => second.usageCount - first.usageCount || first.index - second.index)
+        .map(({ groupedCommitment }) => groupedCommitment);
+}
+/**
+ * Renders a real selected server agent as the manual's practical example.
+ *
+ * @param agent - Agent source selected for the manual.
+ * @param dictionary - Translated labels of the manual.
+ * @returns Markdown section for one baked agent example.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderBakedAgentExampleSection(agent, dictionary) {
+    const usedCommitmentTypes = Array.from(new Set(parseAgentSourceWithCommitments(agent.agentSource).commitments.map((commitment) => commitment.type)));
+    const usedCommitmentsMarkdown = usedCommitmentTypes.map((type) => `\`${type}\``).join(', ');
     return spaceTrim$1((block) => `
-            ### <a id="commitment-${toStableAnchorId(primary.type)}"></a>${primary.icon} ${primary.type}
+            ### <a id="example-${toStableAnchorId(agent.agentName)}"></a>${agent.agentName}
 
-            - **Status:** ${status}
-            - **Aliases:** ${aliasText}
-            - **Semantics:** ${primary.description}
-            - **Type schema (\`createTypeRegex\`):** \`${stringifyRegex(primary.createTypeRegex())}\`
-            - **Block schema (\`createRegex\`):** \`${stringifyRegex(primary.createRegex())}\`
-            ${noticeText}
+            **${dictionary.exampleLabels.commitmentsUsed}:** ${usedCommitmentsMarkdown || dictionary.exampleLabels.noCommitments}
 
-            ${block(documentationMarkdown)}
+            **${dictionary.exampleLabels.fullSource}**
+
+            ${block(getSafeCodeBlock(agent.agentSource, 'book'))}
         `);
 }
 /**
  * Renders one end-to-end example section.
  *
  * @param example - Example definition.
+ * @param dictionary - Translated labels and example prose of the manual.
  * @returns Markdown section for one example.
  *
  * @private internal utility of `createStandaloneBookLanguageMarkdown`
  */
-function renderExampleSection(example) {
+function renderExampleSection(example, dictionary) {
+    const exampleText = dictionary.exampleTexts[example.id];
+    if (exampleText === undefined) {
+        return '';
+    }
     return spaceTrim$1((block) => `
-            ### <a id="example-${toStableAnchorId(example.id)}"></a>${example.title}
+            ### <a id="example-${toStableAnchorId(example.id)}"></a>${exampleText.title}
 
-            **Goal:** ${example.goal}
+            **${dictionary.exampleLabels.goal}:** ${exampleText.goal}
 
-            **Full source**
+            **${dictionary.exampleLabels.fullSource}**
 
             ${block(getSafeCodeBlock(example.source, 'book'))}
 
-            **Walkthrough**
+            **${dictionary.exampleLabels.walkthrough}**
 
-            ${block(example.walkthrough.map((step, index) => `${index + 1}. ${step}`).join('\n'))}
+            ${block(exampleText.walkthrough.map((step, index) => `${index + 1}. ${step}`).join('\n'))}
         `);
 }
-/**
- * Converts a heading label into a stable markdown anchor id.
- *
- * @param value - Raw heading/identifier text.
- * @returns Stable lowercase anchor id.
- *
- * @private internal utility of `createStandaloneBookLanguageMarkdown`
- */
-function toStableAnchorId(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}
-/**
- * Converts a regular expression into a concise literal-like string.
- *
- * @param regex - Regex instance.
- * @returns Printable regex pattern and flags.
- *
- * @private internal utility of `createStandaloneBookLanguageMarkdown`
- */
-function stringifyRegex(regex) {
-    return `/${regex.source}/${regex.flags}`;
-}
-/**
- * Creates a safe markdown fenced code block even when content contains backticks.
- *
- * @param content - Raw code content.
- * @param language - Optional info-string language label.
- * @returns Fenced code block.
- *
- * @private internal utility of `createStandaloneBookLanguageMarkdown`
- */
-function getSafeCodeBlock(content, language = 'markdown') {
-    const maxBacktickCount = Math.max(0, ...(content.match(/`+/g) || []).map((match) => match.length));
-    const fence = '`'.repeat(Math.max(3, maxBacktickCount + 1));
-    return `${fence}${language}\n${content}\n${fence}`;
-}
 
 /**
  * Generates an image for the agent to use as profile image
@@ -30592,6 +31495,44 @@ function $randomBase58(length) {
     return result;
 }
 
+/**
+ * Escapes SQL `LIKE`/`ILIKE` wildcard characters so that a value is matched literally.
+ *
+ * The escape character `\` itself, the multi-character wildcard `%` and the single-character
+ * wildcard `_` are prefixed with a backslash. This turns a case-insensitive `ilike` lookup into
+ * an exact (but still case-insensitive) match instead of an unintended pattern match.
+ *
+ * @param value - Raw value that will be embedded into an `ilike` pattern.
+ * @returns Value with every `LIKE` special character escaped.
+ *
+ * @private internal helper of `buildAgentNameOrPermanentIdFilter`
+ */
+function escapeLikePattern(value) {
+    return value.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_');
+}
+/**
+ * Builds a Supabase `.or()` filter that matches an agent by its human-readable name or its permanent id.
+ *
+ * The human-readable `agentName` is matched exactly, while the `permanentId` is matched
+ * case-insensitively (via `ilike`) so that the same permanent id resolves to the same agent
+ * regardless of the letter casing used in the URL.
+ *
+ * Supabase/PostgREST filters expect values to be URL-encoded so that characters like spaces or
+ * punctuation do not break the query syntax (e.g. `agentName.eq.AI Team`). The permanent-id value is
+ * additionally `LIKE`-escaped so that a name containing wildcard characters cannot be interpreted as
+ * a pattern.
+ *
+ * @param agentNameOrPermanentId - Agent name or stable permanent identifier to match.
+ * @returns `.or()` filter string safe to pass to Supabase.
+ *
+ * @private internal helper shared by `AgentCollectionInSupabase` and the Agents Server agent lookups
+ */
+function buildAgentNameOrPermanentIdFilter(agentNameOrPermanentId) {
+    const encodedAgentName = encodeURIComponent(agentNameOrPermanentId);
+    const encodedPermanentId = encodeURIComponent(escapeLikePattern(agentNameOrPermanentId));
+    return `agentName.eq.${encodedAgentName},permanentId.ilike.${encodedPermanentId}`;
+}
+
 /**
  * Normalizes one agent source before persistence.
  *
@@ -30708,18 +31649,6 @@ function normalizeHistoryVersionName(versionName) {
     const normalizedVersionName = versionName.trim();
     return normalizedVersionName.length > 0 ? normalizedVersionName : null;
 }
-/**
- * Builds a Supabase `.or()` filter for agent name or permanent id lookups.
- *
- * @param agentNameOrPermanentId - Agent name or stable permanent identifier to match.
- * @returns `.or()` filter string safe to pass to Supabase.
- *
- * @private internal helper of `AgentCollectionInSupabase`
- */
-function buildAgentNameOrPermanentIdFilter(agentNameOrPermanentId) {
-    const encodedAgentIdentifier = encodeURIComponent(agentNameOrPermanentId);
-    return `agentName.eq.${encodedAgentIdentifier},permanentId.eq.${encodedAgentIdentifier}`;
-}
 /**
  * Agent collection stored in a Supabase table.
  *