@promptbook/browser 0.114.0-4 → 0.114.0-41

package/esm/index.es.js

@@ -26,7 +26,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.114.0-4';
+const PROMPTBOOK_ENGINE_VERSION = '0.114.0-41';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2603,6 +2603,12 @@ class FromCommitmentDefinition extends BaseCommitmentDefinition {
 
             Inherits agent source from another agent.
 
+            Every agent inherits from the core agent \`@Adam\` unless it says otherwise, so writing no ${this.type} at all
+            is the same as writing \`${this.type} @Adam\`. Write \`${this.type} @Null\` to inherit from nothing.
+
+            An agent has exactly one parent, so when ${this.type} is written more than once, the last one wins and
+            overrides every earlier one.
+
             ## Examples
 
             \`\`\`book
@@ -2611,6 +2617,13 @@ class FromCommitmentDefinition extends BaseCommitmentDefinition {
             FROM https://s6.ptbk.io/benjamin-white
             RULE Speak only in English.
             \`\`\`
+
+            \`\`\`book
+            My Standalone Agent
+
+            FROM @Null
+            RULE Speak only in English.
+            \`\`\`
         `);
     }
     applyToAgentModelRequirements(requirements, content) {
@@ -4115,6 +4128,13 @@ function darken(amount) {
 }
 
 /* eslint-disable no-magic-numbers */
+// Note: [💞] Ignore a discrepancy between file name and entity name
+/**
+ * Default square size used by avatar renderers.
+ *
+ * @private utility of the avatar rendering system
+ */
+const DEFAULT_AVATAR_SIZE = 192;
 /**
  * Corner radius ratio used for the common rounded card frame.
  *
@@ -4485,6 +4505,15 @@ const OUTLINE_GLYPHS = ['#', '%', '@'];
  * @private helper of `asciiOctopusAvatarVisual`
  */
 const ATMOSPHERE_GLYPHS = ['.', ':', "'", '`'];
+/**
+ * Coordinate space the octopus layout is generated in when it is painted into a terminal.
+ *
+ * The terminal renderer has its own character grid, so the geometry only needs one stable
+ * square coordinate space which the grid is then sampled from.
+ *
+ * @private helper of `asciiOctopusAvatarVisual`
+ */
+const TERMINAL_ASCII_OCTOPUS_LAYOUT_SIZE = DEFAULT_AVATAR_SIZE;
 /**
  * AsciiOctopus avatar visual.
  *
@@ -4501,41 +4530,115 @@ const asciiOctopusAvatarVisual = {
         const staticRandom = createRandom('ascii-octopus-static');
         const gridMetrics = createAsciiGridMetrics(size, gridRandom);
         const layout = createAsciiOctopusLayout(size, timeMs, createRandom, staticRandom, interaction);
+        const glyphGrid = createAsciiOctopusGlyphGrid({
+            sampleGrid: gridMetrics,
+            layout,
+            palette,
+            cellRandom: createRandom('ascii-octopus-cells'),
+            timeMs,
+        });
         drawAvatarFrame(context, size, palette);
         drawAsciiBackdrop(context, size, palette, layout, timeMs);
         context.save();
         context.font = `600 ${gridMetrics.fontSize}px monospace`;
         context.textAlign = 'center';
         context.textBaseline = 'middle';
-        // The ASCII renderer samples the morphing octopus field on a low-resolution grid so the shape stays organic
-        // while the glyph layout remains deterministic for the same avatar input.
-        const cellRandom = createRandom('ascii-octopus-cells');
         for (let rowIndex = 0; rowIndex < gridMetrics.rowCount; rowIndex++) {
             for (let columnIndex = 0; columnIndex < gridMetrics.columnCount; columnIndex++) {
-                const point = {
-                    x: gridMetrics.offsetX + columnIndex * gridMetrics.cellWidth,
-                    y: gridMetrics.offsetY + rowIndex * gridMetrics.cellHeight,
-                };
-                const noise = cellRandom();
-                const glyphDescriptor = resolveAsciiGlyph({
-                    point,
-                    layout,
-                    palette,
-                    cellWidth: gridMetrics.cellWidth,
-                    cellHeight: gridMetrics.cellHeight,
-                    noise,
-                    timeMs,
-                });
+                const glyphDescriptor = glyphGrid[rowIndex][columnIndex];
                 if (!glyphDescriptor) {
                     continue;
                 }
+                const point = resolveAsciiSampleGridPoint(gridMetrics, columnIndex, rowIndex);
                 context.fillStyle = glyphDescriptor.color;
                 context.fillText(glyphDescriptor.character, point.x, point.y);
             }
         }
         context.restore();
     },
+    renderTerminalText({ columns, rows, palette, createRandom, timeMs, interaction }) {
+        const staticRandom = createRandom('ascii-octopus-static');
+        const layout = createAsciiOctopusLayout(TERMINAL_ASCII_OCTOPUS_LAYOUT_SIZE, timeMs, createRandom, staticRandom, interaction);
+        return createAsciiOctopusGlyphGrid({
+            sampleGrid: createAsciiTerminalSampleGrid(columns, rows),
+            layout,
+            palette,
+            cellRandom: createRandom('ascii-octopus-cells'),
+            timeMs,
+        });
+    },
 };
+/**
+ * Resolves the geometry point sampled for one cell of the grid.
+ *
+ * @param sampleGrid Character-cell sampling grid.
+ * @param columnIndex Zero-based cell column.
+ * @param rowIndex Zero-based cell row.
+ * @returns Sampled point in the octopus coordinate space.
+ *
+ * @private helper of `asciiOctopusAvatarVisual`
+ */
+function resolveAsciiSampleGridPoint(sampleGrid, columnIndex, rowIndex) {
+    return {
+        x: sampleGrid.offsetX + columnIndex * sampleGrid.cellWidth,
+        y: sampleGrid.offsetY + rowIndex * sampleGrid.cellHeight,
+    };
+}
+/**
+ * Builds the sampling grid used when the octopus is painted straight into terminal character cells.
+ *
+ * @param columns Available terminal columns.
+ * @param rows Available terminal rows.
+ * @returns Character-cell sampling grid covering the whole octopus coordinate space.
+ *
+ * @private helper of `asciiOctopusAvatarVisual`
+ */
+function createAsciiTerminalSampleGrid(columns, rows) {
+    const cellWidth = TERMINAL_ASCII_OCTOPUS_LAYOUT_SIZE / columns;
+    const cellHeight = TERMINAL_ASCII_OCTOPUS_LAYOUT_SIZE / rows;
+    return {
+        cellWidth,
+        cellHeight,
+        columnCount: columns,
+        rowCount: rows,
+        offsetX: cellWidth / 2,
+        offsetY: cellHeight / 2,
+    };
+}
+/**
+ * Samples the morphing octopus field into one deterministic grid of ASCII glyphs.
+ *
+ * The field is sampled on a low-resolution grid so the shape stays organic while the glyph
+ * layout remains deterministic for the same avatar input. Both the canvas visual and the
+ * terminal visual share this single sampling pass so they always describe the same octopus.
+ *
+ * @param options Sampling grid, prepared octopus layout, palette, per-cell noise, and animation time.
+ * @returns Resolved glyph of every sampled cell, where `null` means an empty cell.
+ *
+ * @private helper of `asciiOctopusAvatarVisual`
+ */
+function createAsciiOctopusGlyphGrid(options) {
+    const { sampleGrid, layout, palette, cellRandom, timeMs } = options;
+    const glyphGrid = [];
+    for (let rowIndex = 0; rowIndex < sampleGrid.rowCount; rowIndex++) {
+        const glyphRow = [];
+        for (let columnIndex = 0; columnIndex < sampleGrid.columnCount; columnIndex++) {
+            const point = resolveAsciiSampleGridPoint(sampleGrid, columnIndex, rowIndex);
+            const noise = cellRandom();
+            glyphRow.push(resolveAsciiGlyph({
+                point,
+                layout,
+                palette,
+                cellWidth: sampleGrid.cellWidth,
+                cellHeight: sampleGrid.cellHeight,
+                noise,
+                timeMs,
+            }));
+        }
+        glyphGrid.push(glyphRow);
+    }
+    return glyphGrid;
+}
 /**
  * Draws the dark terminal-like glow behind the ASCII octopus.
  *
@@ -16932,29 +17035,36 @@ class UseUserLocationCommitmentDefinition extends BaseCommitmentDefinition {
 /**
  * `WRITING RULES` commitment definition.
  *
- * It adds constraints that apply strictly to writing style and presentation
- * rather than task-solving behavior.
+ * The `WRITING RULES`/`WRITING RULE` commitment adds constraints that apply strictly to writing style
+ * and presentation rather than task-solving behavior.
+ *
+ * Example usage in agent source:
+ *
+ * ```book
+ * WRITING RULES Keep every response under 120 words
+ * WRITING RULE Always end the message with an emoji
+ * ```
  *
  * @private [🪔] Maybe export the commitments through some package
  */
 class WritingRulesCommitmentDefinition extends BaseCommitmentDefinition {
-    constructor() {
-        super('WRITING RULES');
+    constructor(type = 'WRITING RULES') {
+        super(type);
     }
     /**
-     * Short one-line description of `WRITING RULES`.
+     * Short one-line description of `WRITING RULES`/`WRITING RULE`.
      */
     get description() {
         return 'Add writing-only constraints such as tone, length, formatting, or emoji usage.';
     }
     /**
-     * Icon for `WRITING RULES`.
+     * Icon for `WRITING RULES`/`WRITING RULE`.
      */
     get icon() {
         return '📝';
     }
     /**
-     * Markdown documentation for `WRITING RULES`.
+     * Markdown documentation for `WRITING RULES`/`WRITING RULE` commitment.
      */
     get documentation() {
         return spaceTrim$1(`
@@ -16964,6 +17074,7 @@ class WritingRulesCommitmentDefinition extends BaseCommitmentDefinition {
 
             ## Key aspects
 
+            - All writing rules are treated equally regardless of singular/plural form.
             - Use it for writing-only constraints such as tone, formatting, length, emoji usage, punctuation, or reading level.
             - Do **not** use it for problem-solving behavior, policy, tool usage, or decision-making logic. Use \`RULE\` for that.
             - Newer writing-rules blocks override conflicting earlier writing-rules blocks.
@@ -17162,7 +17273,8 @@ const COMMITMENT_REGISTRY = [
     new LanguageCommitmentDefinition('LANGUAGE'),
     new LanguageCommitmentDefinition('LANGUAGES'),
     new WritingSampleCommitmentDefinition(),
-    new WritingRulesCommitmentDefinition(),
+    new WritingRulesCommitmentDefinition('WRITING RULES'),
+    new WritingRulesCommitmentDefinition('WRITING RULE'),
     new SampleCommitmentDefinition('SAMPLE'),
     new SampleCommitmentDefinition('EXAMPLE'),
     new FormatCommitmentDefinition('FORMAT'),
@@ -18470,6 +18582,30 @@ function createDefaultAgentName(agentSource) {
     return normalizeAgentName(`Agent ${agentHash.substring(0, LIMITS.SHORT_NAME_LENGTH)}`);
 }
 
+/**
+ * Pattern shared by Book parsing and editor highlighting for a commitment-like line.
+ *
+ * A Book commitment keyword consists of one or more all-uppercase words with at least
+ * two characters each. This deliberately mirrors the Book editor syntax rule so an
+ * unknown keyword starts a new source block everywhere it is interpreted.
+ *
+ * @private internal constant of `getBookCommitmentLineType`
+ */
+const BOOK_COMMITMENT_LINE_TYPE_REGEX = /^\s*(?<type>[A-Z][A-Z0-9]+(?:\s+[A-Z][A-Z0-9]+)*)(?=\s|$)/;
+/**
+ * Extracts the uppercase commitment type from a Book line, including types not registered by Promptbook.
+ *
+ * @param line - One raw Book source line.
+ * @returns Matched commitment type or `null` when the line does not begin with commitment syntax.
+ *
+ * @private internal utility of Book parsing and `<BookEditor/>`
+ */
+function getBookCommitmentLineType(line) {
+    var _a;
+    const match = BOOK_COMMITMENT_LINE_TYPE_REGEX.exec(line);
+    return ((_a = match === null || match === void 0 ? void 0 : match.groups) === null || _a === void 0 ? void 0 : _a.type) || null;
+}
+
 /**
  * Consumes the agent-name prelude from raw source.
  *
@@ -18527,13 +18663,15 @@ function parseAgentSourceWithCommitments(agentSource) {
         return {
             agentName: null,
             commitments: [],
+            unknownCommitments: [],
             nonCommitmentLines: [],
         };
     }
     const { lines, agentName, agentNameLineIndex, agentNameLineNumber } = parseAgentSourcePrelude(agentSource);
     const commitments = [];
+    const unknownCommitments = [];
     const nonCommitmentLines = agentNameLineIndex >= 0 ? [lines[agentNameLineIndex]] : [];
-    // Parse commitments with multiline support
+    // Parse commitments with multiline support.
     let currentCommitment = null;
     // Process lines starting from after the agent name line
     const startIndex = agentNameLineIndex >= 0 ? agentNameLineIndex + 1 : 0;
@@ -18547,25 +18685,11 @@ function parseAgentSourceWithCommitments(agentSource) {
         // Check if this line starts or ends a code block
         if (trimmedLine.startsWith('```')) {
             isInsideCodeBlock = !isInsideCodeBlock;
-            if (currentCommitment) {
-                // If we are inside a commitment, the code block is part of it
-                currentCommitment.contentLines.push(line);
-            }
-            else {
-                // If we are not inside a commitment, the code block is non-commitment
-                nonCommitmentLines.push(line);
-            }
+            appendLineToCurrentCommitmentOrNonCommitmentLines(currentCommitment, line, nonCommitmentLines);
             continue;
         }
         if (isInsideCodeBlock) {
-            if (currentCommitment) {
-                // If we are inside a commitment and a code block, the line is part of the commitment
-                currentCommitment.contentLines.push(line);
-            }
-            else {
-                // If we are inside a code block but not a commitment, the line is non-commitment
-                nonCommitmentLines.push(line);
-            }
+            appendLineToCurrentCommitmentOrNonCommitmentLines(currentCommitment, line, nonCommitmentLines);
             continue;
         }
         // Check if this line starts a new commitment
@@ -18574,22 +18698,14 @@ function parseAgentSourceWithCommitments(agentSource) {
             const typeRegex = definition.createTypeRegex();
             const match = typeRegex.exec(line.trim());
             if (match && ((_a = match.groups) === null || _a === void 0 ? void 0 : _a.type)) {
-                // Save the previous commitment if it exists
-                if (currentCommitment) {
-                    const fullContent = currentCommitment.contentLines.join('\n');
-                    commitments.push({
-                        type: currentCommitment.type,
-                        content: spaceTrim$1(fullContent),
-                        originalLine: currentCommitment.originalStartLine,
-                        lineNumber: currentCommitment.startLineNumber,
-                    });
-                }
+                appendCurrentCommitment(currentCommitment, commitments, unknownCommitments);
                 // Extract the initial content from the commitment line
                 const fullRegex = definition.createRegex();
                 const fullMatch = fullRegex.exec(line.trim());
                 const initialContent = ((_b = fullMatch === null || fullMatch === void 0 ? void 0 : fullMatch.groups) === null || _b === void 0 ? void 0 : _b.contents) || '';
                 // Start a new commitment
                 currentCommitment = {
+                    kind: 'known',
                     type: definition.type,
                     startLineNumber: i + 1,
                     originalStartLine: line,
@@ -18599,52 +18715,90 @@ function parseAgentSourceWithCommitments(agentSource) {
                 break;
             }
         }
+        if (foundNewCommitment) {
+            continue;
+        }
+        const unknownCommitmentType = getBookCommitmentLineType(line);
+        if (unknownCommitmentType) {
+            appendCurrentCommitment(currentCommitment, commitments, unknownCommitments);
+            currentCommitment = {
+                kind: 'unknown',
+                type: unknownCommitmentType,
+                startLineNumber: i + 1,
+                originalStartLine: line,
+                sourceLines: [line],
+            };
+            continue;
+        }
         // Check if this is a horizontal line (ends any current commitment)
         const isHorizontalLine = HORIZONTAL_LINE_PATTERN$1.test(line);
         if (isHorizontalLine) {
-            // Save the current commitment if it exists
-            if (currentCommitment) {
-                const fullContent = currentCommitment.contentLines.join('\n');
-                commitments.push({
-                    type: currentCommitment.type,
-                    content: spaceTrim$1(fullContent),
-                    originalLine: currentCommitment.originalStartLine,
-                    lineNumber: currentCommitment.startLineNumber,
-                });
-                currentCommitment = null;
-            }
+            appendCurrentCommitment(currentCommitment, commitments, unknownCommitments);
+            currentCommitment = null;
             // Add horizontal line to non-commitment lines
             nonCommitmentLines.push(line);
             continue;
         }
-        if (!foundNewCommitment) {
-            if (currentCommitment) {
-                // This line belongs to the current commitment
-                currentCommitment.contentLines.push(line);
-            }
-            else {
-                // This line is not part of any commitment
-                nonCommitmentLines.push(line);
-            }
-        }
-    }
-    // Don't forget to save the last commitment if it exists
-    if (currentCommitment) {
-        const fullContent = currentCommitment.contentLines.join('\n');
-        commitments.push({
-            type: currentCommitment.type,
-            content: spaceTrim$1(fullContent),
-            originalLine: currentCommitment.originalStartLine,
-            lineNumber: currentCommitment.startLineNumber,
-        });
+        appendLineToCurrentCommitmentOrNonCommitmentLines(currentCommitment, line, nonCommitmentLines);
     }
+    appendCurrentCommitment(currentCommitment, commitments, unknownCommitments);
     return {
         agentName,
         agentNameLineNumber,
         commitments,
+        unknownCommitments,
         nonCommitmentLines,
     };
 }
+/**
+ * Stores the current known or unknown commitment in its appropriate parsed collection.
+ *
+ * @param currentCommitment - Commitment-like block collected so far.
+ * @param commitments - Parsed registered commitments to append to.
+ * @param unknownCommitments - Parsed unregistered commitments to append to.
+ *
+ * @private internal utility of `parseAgentSourceWithCommitments`
+ */
+function appendCurrentCommitment(currentCommitment, commitments, unknownCommitments) {
+    if (!currentCommitment) {
+        return;
+    }
+    if (currentCommitment.kind === 'unknown') {
+        unknownCommitments.push({
+            type: currentCommitment.type,
+            originalLine: currentCommitment.originalStartLine,
+            lineNumber: currentCommitment.startLineNumber,
+            source: spaceTrim$1(currentCommitment.sourceLines.join('\n')),
+        });
+        return;
+    }
+    commitments.push({
+        type: currentCommitment.type,
+        content: spaceTrim$1(currentCommitment.contentLines.join('\n')),
+        originalLine: currentCommitment.originalStartLine,
+        lineNumber: currentCommitment.startLineNumber,
+    });
+}
+/**
+ * Adds one source line to the active commitment-like block, or to plain source content when none is active.
+ *
+ * @param currentCommitment - Commitment-like block currently being collected.
+ * @param line - Source line to append.
+ * @param nonCommitmentLines - Plain source lines to append to when no block is active.
+ *
+ * @private internal utility of `parseAgentSourceWithCommitments`
+ */
+function appendLineToCurrentCommitmentOrNonCommitmentLines(currentCommitment, line, nonCommitmentLines) {
+    if (!currentCommitment) {
+        nonCommitmentLines.push(line);
+        return;
+    }
+    if (currentCommitment.kind === 'unknown') {
+        currentCommitment.sourceLines.push(line);
+        return;
+    }
+    currentCommitment.contentLines.push(line);
+}
 
 /**
  * Parses parameters from text using both supported notations:
@@ -19545,7 +19699,7 @@ function validateBook(source) {
 padBook(validateBook(spaceTrim$1(`
             AI Avatar
 
-            PERSONA A friendly AI assistant that helps you with your tasks
+            GOAL Help users with their tasks as a friendly AI assistant.
         `)));
 // <- Note: Not using book`...` notation to avoid strange error in jest unit tests `TypeError: (0 , book_notation_1.book) is not a function`
 // <- TODO: [🐱‍🚀] `GENESIS_BOOK` / `ADAM_BOOK` in `/agents/adam.book`
@@ -26427,7 +26581,8 @@ async function augmentAgentModelRequirementsFromSource(requirements, parseResult
     requirements = await importReferencedFiles(requirements);
     requirements = appendMcpServers(requirements, agentSource);
     requirements = appendNonCommitmentContent(requirements, parseResult);
-    return appendExampleInteractions(requirements, parseResult);
+    requirements = appendExampleInteractions(requirements, parseResult);
+    return appendUnknownCommitmentContent(requirements, parseResult);
 }
 /**
  * Imports text files referenced by IMPORT commitments and appends their transformed content to the system message.
@@ -26549,6 +26704,36 @@ function appendNonCommitmentContent(requirements, parseResult) {
     }
     return appendSystemMessageSection(requirements, nonCommitmentContent);
 }
+/**
+ * Appends unknown commitment blocks as final extra context without applying commitment side effects.
+ *
+ * @param requirements - Current requirements snapshot.
+ * @param parseResult - Parsed source including unknown commitment blocks.
+ * @returns Requirements with unknown commitment context appended at the end of the system message.
+ *
+ * @private internal utility of `augmentAgentModelRequirementsFromSource`
+ */
+function appendUnknownCommitmentContent(requirements, parseResult) {
+    const unknownCommitmentContent = getUnknownCommitmentContent(parseResult);
+    if (!unknownCommitmentContent) {
+        return requirements;
+    }
+    return appendSystemMessageSection(requirements, unknownCommitmentContent);
+}
+/**
+ * Joins unknown commitment blocks into their final extra-context representation.
+ *
+ * @param parseResult - Parsed source including unknown commitment blocks.
+ * @returns Unknown commitment source blocks in their original order.
+ *
+ * @private internal utility of `appendUnknownCommitmentContent`
+ */
+function getUnknownCommitmentContent(parseResult) {
+    return parseResult.unknownCommitments
+        .map((commitment) => commitment.source)
+        .filter(Boolean)
+        .join('\n\n');
+}
 /**
  * Collects plain-text lines that were not parsed as commitments and should still become part of the final system message.
  *
@@ -26876,6 +27061,245 @@ function stripInlineKnowledgeMetadata(metadata) {
     return Object.keys(rest).length > 0 ? rest : undefined;
 }
 
+/**
+ * Pattern matching a markdown section heading (`## Title`) that separates system-message sections
+ *
+ * @private internal constant of `deduplicateSystemMessage`
+ */
+const SYSTEM_MESSAGE_SECTION_HEADING_PATTERN = /^##(?!#)\s*(.+?)\s*$/;
+/**
+ * Pattern matching a fenced code block delimiter which suspends section and block splitting
+ *
+ * @private internal constant of `deduplicateSystemMessage`
+ */
+const CODE_FENCE_PATTERN = /^\s*(?:```|~~~)/;
+/**
+ * Pattern matching a markdown list item which keeps merged bullet lists visually compact
+ *
+ * @private internal constant of `deduplicateSystemMessage`
+ */
+const LIST_ITEM_PATTERN = /^\s*(?:[-*+]|\d+[.)])\s/;
+/**
+ * Removes duplicated instructions from a generated system message
+ *
+ * Commitments are applied one by one, so a commitment used multiple times in one book repeats its whole
+ * section, including the shared guidance preamble. For example two `WRITING RULES` commitments emit the
+ * `## Writing rules` heading and its guidance paragraph twice. This function merges all sections sharing
+ * one heading into the position of their first occurrence and keeps every identical block only once.
+ *
+ * @param systemMessage The assembled system message which may contain repeated sections and blocks
+ * @returns The system message where each section heading and each identical block appears exactly once
+ *
+ * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ */
+function deduplicateSystemMessage(systemMessage) {
+    if (!systemMessage.trim()) {
+        return systemMessage;
+    }
+    return splitSystemMessageIntoRegions(systemMessage)
+        .reduce(mergeRegionSharingHeading, [])
+        .map(removeDuplicateBlocksFromRegion)
+        .map(renderRegion)
+        .filter((renderedRegion) => renderedRegion !== '')
+        .join('\n\n');
+}
+/**
+ * Splits the system message into the intro region and one region per `## Title` section
+ *
+ * @param systemMessage The system message to split
+ * @returns Regions in their original order, without empty ones
+ *
+ * @private internal utility of `deduplicateSystemMessage`
+ */
+function splitSystemMessageIntoRegions(systemMessage) {
+    const regions = [];
+    let headingLine = null;
+    let bodyLines = [];
+    let isInsideCodeFence = false;
+    for (const line of systemMessage.split(/\r?\n/)) {
+        if (CODE_FENCE_PATTERN.test(line)) {
+            isInsideCodeFence = !isInsideCodeFence;
+        }
+        if (isInsideCodeFence || !SYSTEM_MESSAGE_SECTION_HEADING_PATTERN.test(line)) {
+            bodyLines.push(line);
+            continue;
+        }
+        regions.push(createRegion(headingLine, bodyLines));
+        headingLine = line;
+        bodyLines = [];
+    }
+    regions.push(createRegion(headingLine, bodyLines));
+    return regions.filter((region) => region.headingLine !== null || region.blocks.length > 0);
+}
+/**
+ * Creates one region from its heading line and its raw body lines
+ *
+ * @param headingLine The original `## Title` line, or `null` for the intro before the first heading
+ * @param bodyLines The raw lines following the heading line
+ * @returns The region with its body already split into blocks
+ *
+ * @private internal utility of `splitSystemMessageIntoRegions`
+ */
+function createRegion(headingLine, bodyLines) {
+    return {
+        titleKey: headingLine === null ? null : normalizeSectionTitle(headingLine),
+        headingLine,
+        isBodySeparatedByBlankLine: bodyLines[0] !== undefined && bodyLines[0].trim() === '',
+        blocks: splitBodyIntoBlocks(bodyLines),
+    };
+}
+/**
+ * Normalizes a heading line into a key usable for matching sections which belong together
+ *
+ * @param headingLine The original `## Title` line
+ * @returns Lowercased title without the markdown heading prefix
+ *
+ * @private internal utility of `createRegion`
+ */
+function normalizeSectionTitle(headingLine) {
+    var _a, _b;
+    return ((_b = (_a = SYSTEM_MESSAGE_SECTION_HEADING_PATTERN.exec(headingLine)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : headingLine).toLowerCase();
+}
+/**
+ * Splits raw body lines into blocks separated by blank lines while keeping fenced code blocks intact
+ *
+ * @param bodyLines The raw lines of one region body
+ * @returns Non-empty blocks in their original order
+ *
+ * @private internal utility of `createRegion`
+ */
+function splitBodyIntoBlocks(bodyLines) {
+    const blockTexts = [];
+    let blockLines = [];
+    let isInsideCodeFence = false;
+    for (const line of bodyLines) {
+        if (CODE_FENCE_PATTERN.test(line)) {
+            isInsideCodeFence = !isInsideCodeFence;
+        }
+        if (!isInsideCodeFence && line.trim() === '') {
+            blockTexts.push(blockLines.join('\n'));
+            blockLines = [];
+            continue;
+        }
+        blockLines.push(line);
+    }
+    blockTexts.push(blockLines.join('\n'));
+    return blockTexts
+        .filter((blockText) => blockText.trim() !== '')
+        .map((blockText) => ({ text: blockText, isOpeningMergedSection: false }));
+}
+/**
+ * Appends one region to the already merged regions, merging it into an earlier region with the same heading
+ *
+ * @param mergedRegions Regions merged so far, used as the reducer accumulator
+ * @param region The next region in original order
+ * @returns The accumulator with the region either appended or merged into its earlier twin
+ *
+ * @private internal utility of `deduplicateSystemMessage`
+ */
+function mergeRegionSharingHeading(mergedRegions, region) {
+    const existingRegionIndex = mergedRegions.findIndex((mergedRegion) => region.titleKey !== null && mergedRegion.titleKey === region.titleKey);
+    if (existingRegionIndex === -1) {
+        return [...mergedRegions, region];
+    }
+    return mergedRegions.map((mergedRegion, index) => index !== existingRegionIndex
+        ? mergedRegion
+        : {
+            ...mergedRegion,
+            blocks: [...mergedRegion.blocks, ...markFirstBlockAsOpeningMergedSection(region.blocks)],
+        });
+}
+/**
+ * Marks the first block of a merged section occurrence so the merge seam can be rendered as one list
+ *
+ * @param blocks The blocks of the section occurrence being merged into an earlier section
+ * @returns The same blocks with the first one marked as opening a merged section
+ *
+ * @private internal utility of `mergeRegionSharingHeading`
+ */
+function markFirstBlockAsOpeningMergedSection(blocks) {
+    return blocks.map((block, index) => (index === 0 ? { ...block, isOpeningMergedSection: true } : block));
+}
+/**
+ * Keeps only the first occurrence of every identical block inside one region
+ *
+ * @param region The region whose blocks may repeat
+ * @returns The region without repeated blocks
+ *
+ * @private internal utility of `deduplicateSystemMessage`
+ */
+function removeDuplicateBlocksFromRegion(region) {
+    const alreadyRenderedTexts = new Set();
+    const uniqueBlocks = [];
+    let isMergeSeamPending = false;
+    for (const block of region.blocks) {
+        if (alreadyRenderedTexts.has(block.text)) {
+            // Note: A removed block must still hand its merge seam over to the next block which survives
+            isMergeSeamPending = isMergeSeamPending || block.isOpeningMergedSection;
+            continue;
+        }
+        alreadyRenderedTexts.add(block.text);
+        uniqueBlocks.push({
+            text: block.text,
+            isOpeningMergedSection: block.isOpeningMergedSection || isMergeSeamPending,
+        });
+        isMergeSeamPending = false;
+    }
+    return { ...region, blocks: uniqueBlocks };
+}
+/**
+ * Renders one region back into its markdown representation
+ *
+ * @param region The region to render
+ * @returns The heading line together with its joined blocks
+ *
+ * @private internal utility of `deduplicateSystemMessage`
+ */
+function renderRegion(region) {
+    const body = joinBlocks(region.blocks);
+    if (region.headingLine === null) {
+        return body;
+    }
+    if (body === '') {
+        return region.headingLine;
+    }
+    return `${region.headingLine}${region.isBodySeparatedByBlankLine ? '\n\n' : '\n'}${body}`;
+}
+/**
+ * Joins blocks of one region back together
+ *
+ * @param blocks The blocks to join in their original order
+ * @returns The joined body of one region
+ *
+ * @private internal utility of `renderRegion`
+ */
+function joinBlocks(blocks) {
+    return blocks
+        .map((block, index) => index === 0 ? block.text : `${createBlockSeparator(blocks[index - 1], block)}${block.text}`)
+        .join('');
+}
+/**
+ * Chooses the separator between two neighboring blocks
+ *
+ * Blocks are normally separated by a blank line, exactly as they were written. Only where two sections were
+ * merged together their lists are joined into one compact list instead of two separate ones.
+ *
+ * @param previousBlock The block rendered before the separator
+ * @param nextBlock The block rendered after the separator
+ * @returns Either a single or a double newline
+ *
+ * @private internal utility of `joinBlocks`
+ */
+function createBlockSeparator(previousBlock, nextBlock) {
+    if (!nextBlock.isOpeningMergedSection) {
+        return '\n\n';
+    }
+    const previousBlockLines = previousBlock.text.split('\n');
+    const isListContinuing = LIST_ITEM_PATTERN.test(previousBlockLines[previousBlockLines.length - 1]) &&
+        LIST_ITEM_PATTERN.test(nextBlock.text.split('\n')[0]);
+    return isListContinuing ? '\n' : '\n\n';
+}
+
 /**
  * Removes single-hash comment lines (`# Comment`) from a system message
  * This is used to clean up the final system message before sending it to the AI model
@@ -26949,14 +27373,14 @@ function createInitialAgentModelRequirements(agentName, modelName) {
  * Performs the final system-message cleanup pass after all other augmentation steps are complete.
  *
  * @param requirements - Fully built requirements before final cleanup.
- * @returns Requirements with comment lines removed from the final system message.
+ * @returns Requirements with comment lines removed and repeated instructions deduplicated in the final system message.
  *
  * @private internal utility of `createAgentModelRequirementsWithCommitments`
  */
 function finalizeRequirements(requirements) {
     return {
         ...requirements,
-        systemMessage: removeCommentsFromSystemMessage(requirements.systemMessage),
+        systemMessage: deduplicateSystemMessage(removeCommentsFromSystemMessage(requirements.systemMessage)),
     };
 }
 
@@ -27632,28 +28056,28 @@ function parseToolExecutionEnvelope(rawValue) {
  */
 function buildToolInvocationScript(options) {
     const { functionName, functionArgsExpression } = options;
-    return `
-        const args = ${functionArgsExpression};
-        const runtimeContextRaw =
-            typeof ${TOOL_RUNTIME_CONTEXT_PARAMETER} === 'undefined'
-                ? undefined
-                : ${TOOL_RUNTIME_CONTEXT_PARAMETER};
-
-        if (runtimeContextRaw !== undefined && args && typeof args === 'object' && !Array.isArray(args)) {
-            args.${TOOL_RUNTIME_CONTEXT_ARGUMENT} = runtimeContextRaw;
-        }
+    return spaceTrim$1((block) => `
+            const args = ${block(functionArgsExpression)};
+            const runtimeContextRaw =
+                typeof ${TOOL_RUNTIME_CONTEXT_PARAMETER} === 'undefined'
+                    ? undefined
+                    : ${TOOL_RUNTIME_CONTEXT_PARAMETER};
+
+            if (runtimeContextRaw !== undefined && args && typeof args === 'object' && !Array.isArray(args)) {
+                args.${TOOL_RUNTIME_CONTEXT_ARGUMENT} = runtimeContextRaw;
+            }
 
-        const toolProgressTokenRaw =
-            typeof ${TOOL_PROGRESS_TOKEN_PARAMETER} === 'undefined'
-                ? undefined
-                : ${TOOL_PROGRESS_TOKEN_PARAMETER};
+            const toolProgressTokenRaw =
+                typeof ${TOOL_PROGRESS_TOKEN_PARAMETER} === 'undefined'
+                    ? undefined
+                    : ${TOOL_PROGRESS_TOKEN_PARAMETER};
 
-        if (toolProgressTokenRaw !== undefined && args && typeof args === 'object' && !Array.isArray(args)) {
-            args.${TOOL_PROGRESS_TOKEN_ARGUMENT} = toolProgressTokenRaw;
-        }
+            if (toolProgressTokenRaw !== undefined && args && typeof args === 'object' && !Array.isArray(args)) {
+                args.${TOOL_PROGRESS_TOKEN_ARGUMENT} = toolProgressTokenRaw;
+            }
 
-        return await ${functionName}(args);
-    `;
+            return await ${functionName}(args);
+        `);
 }
 
 /**