@promptbook/remote-server 0.114.0-4 → 0.114.0-41

package/umd/index.umd.js

@@ -50,7 +50,7 @@
      * @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
@@ -8737,23 +8737,27 @@
     // TODO: [🧠][♿] Maybe export through `@promptbook/node`
 
     /**
-     * Attempts to locate the specified application on a Windows system by searching common installation directories.
+     * Attempts to locate the specified application on a Windows system by searching PATH and common installation directories.
      * Returns the path to the executable if found, or null otherwise.
      *
      * @private within the repository
      */
     async function locateAppOnWindows({ appName, windowsSuffix, }) {
         try {
-            const prefixes = [
+            const EXECUTABLE_FILENAME = windowsSuffix.replace(/^.*[\\/]/, '');
+            const PATH_EXECUTABLE_PATHS = (process.env.PATH || '')
+                .split(path.delimiter)
+                .filter(Boolean)
+                .map((pathPrefix) => path.join(pathPrefix, EXECUTABLE_FILENAME));
+            const INSTALLATION_EXECUTABLE_PATHS = [
                 process.env.LOCALAPPDATA,
                 path.join(process.env.LOCALAPPDATA || '', 'Programs'),
                 process.env.PROGRAMFILES,
                 process.env['PROGRAMFILES(X86)'],
-            ];
-            for (const prefix of prefixes) {
-                const path = prefix + windowsSuffix;
-                if (await isExecutable(path, $provideFilesystemForNode())) {
-                    return path;
+            ].map((pathPrefix) => pathPrefix + windowsSuffix);
+            for (const executablePath of [...PATH_EXECUTABLE_PATHS, ...INSTALLATION_EXECUTABLE_PATHS]) {
+                if (await isExecutable(executablePath, $provideFilesystemForNode())) {
+                    return executablePath;
                 }
             }
             throw new Error(`Can not locate app ${appName} on Windows.`);
@@ -10451,6 +10455,12 @@
 
             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
@@ -10459,6 +10469,13 @@
             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) {
@@ -11591,6 +11608,13 @@
     }
 
     /* 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.
      *
@@ -11961,6 +11985,15 @@
      * @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.
      *
@@ -11977,41 +12010,115 @@
             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.
      *
@@ -24315,29 +24422,36 @@
     /**
      * `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.spaceTrim(`
@@ -24347,6 +24461,7 @@
 
             ## 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.
@@ -24545,7 +24660,8 @@
         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'),
@@ -28829,7 +28945,7 @@
     padBook(validateBook(_spaceTrim.spaceTrim(`
             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`
@@ -29224,6 +29340,30 @@
         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.
      *
@@ -29281,13 +29421,15 @@
             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;
@@ -29301,25 +29443,11 @@
             // 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
@@ -29328,22 +29456,14 @@
                 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.spaceTrim(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,
@@ -29353,52 +29473,90 @@
                     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.spaceTrim(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.spaceTrim(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.spaceTrim(currentCommitment.sourceLines.join('\n')),
+            });
+            return;
+        }
+        commitments.push({
+            type: currentCommitment.type,
+            content: _spaceTrim.spaceTrim(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:
@@ -30491,7 +30649,8 @@
         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.
@@ -30613,6 +30772,36 @@
         }
         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.
      *
@@ -30940,6 +31129,245 @@
         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
@@ -31013,14 +31441,14 @@
      * 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)),
         };
     }
 
@@ -31683,28 +32111,28 @@
      */
     function buildToolInvocationScript(options) {
         const { functionName, functionArgsExpression } = options;
-        return `
-        const args = ${functionArgsExpression};
-        const runtimeContextRaw =
-            typeof ${TOOL_RUNTIME_CONTEXT_PARAMETER} === 'undefined'
-                ? undefined
-                : ${TOOL_RUNTIME_CONTEXT_PARAMETER};
+        return _spaceTrim.spaceTrim((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;
-        }
+            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);
+        `);
     }
 
     /**