@promptbook/cli 0.114.0-35 → 0.114.0-38

package/esm/scripts/run-codex-prompts/common/resolveCoderAgent.d.ts

@@ -7,6 +7,13 @@ export type ResolvedCoderAgentBook = {
      * Raw source of the agent `.book` file.
      */
     readonly agentSource: string_book;
+    /**
+     * Human-readable name of the agent, as it is reported in prompt status lines and run traces.
+     *
+     * Comes from the `META FULLNAME` of the Book, or from the plain title on its first line, so it is the
+     * display name of the agent and not its normalized identifier.
+     */
+    readonly agentName: string;
     /**
      * Equivalent references by which a prompt may target this agent.
      *

package/esm/scripts/run-codex-prompts/main/resolvePromptRunner.d.ts

@@ -1,12 +1,6 @@
 import type { RunOptions } from '../cli/RunOptions';
+import type { PromptRunnerMetadata } from '../common/PromptRunnerMetadata';
 import type { PromptRunner } from '../runners/types/PromptRunner';
-/**
- * Runner metadata used in prompt status lines.
- */
-type RunnerMetadata = {
-    runnerName: string;
-    modelName?: string;
-};
 /**
  * Subset of `RunOptions` which decides which prompt runner is created and how it is labeled.
  *
@@ -20,7 +14,10 @@ export type PromptRunnerSelectionOptions = Pick<RunOptions, 'agentName' | 'model
 type PromptRunnerResolution = {
     runner: PromptRunner;
     actualRunnerModel?: string;
-    runnerMetadata: RunnerMetadata;
+    /**
+     * Harness half of the run metadata; the optional Book agent is added by the caller which resolves it.
+     */
+    runnerMetadata: PromptRunnerMetadata;
 };
 /**
  * Resolves the configured prompt runner together with status-line metadata.

package/esm/scripts/run-codex-prompts/main/runPromptRound.d.ts

@@ -1,6 +1,7 @@
 import type { RunOptions } from '../cli/RunOptions';
 import type { CliProgressDisplay } from '../common/cliProgressDisplay';
 import type { WaitForCoderRunPauseCheckpoint } from '../common/CoderRunPauseCheckpoint';
+import type { PromptRunnerMetadata } from '../common/PromptRunnerMetadata';
 import type { PromptSelection } from '../prompts/types/PromptSelection';
 import type { PromptRunner } from '../runners/types/PromptRunner';
 import type { CoderRunUiHandle } from '../ui/renderCoderRunUi';
@@ -10,10 +11,7 @@ import type { CoderRunUiHandle } from '../ui/renderCoderRunUi';
 export type RunPromptRoundOptions = {
     options: RunOptions;
     runner: PromptRunner;
-    runnerMetadata: {
-        runnerName: string;
-        modelName?: string;
-    };
+    runnerMetadata: PromptRunnerMetadata;
     nextPrompt: PromptSelection;
     promptLabel: string;
     resolvedCoderContext?: string;

package/esm/scripts/run-codex-prompts/prompts/buildPromptRunTraceContent.d.ts

@@ -1,7 +1,7 @@
 import moment from 'moment';
 import { type CodexLoginMethod } from '../../../src/book-3.0/codexLoginMethod';
-import type { ThinkingLevel } from '../../../src/cli/cli-commands/coder/ThinkingLevel';
 import type { CoderRunStep } from '../common/CoderRunStep';
+import { type FormatRunnerSignatureOptions } from './formatRunnerSignature';
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSection } from './types/PromptSection';
 /**
@@ -29,21 +29,9 @@ export type PromptRunTraceOutcome = {
 /**
  * Everything one run trace says about the prompt round it describes.
  */
-export type BuildPromptRunTraceContentOptions = {
+export type BuildPromptRunTraceContentOptions = FormatRunnerSignatureOptions & {
     readonly file: PromptFile;
     readonly section: PromptSection;
-    /**
-     * Harness which ran the prompt.
-     */
-    readonly runnerName?: string;
-    /**
-     * Model the harness ran the prompt with.
-     */
-    readonly modelName?: string;
-    /**
-     * Reasoning effort the harness ran the prompt with.
-     */
-    readonly thinkingLevel?: ThinkingLevel;
     /**
      * Verification command the round ran after each coding attempt, when one is configured.
      */
@@ -70,8 +58,8 @@ export type BuildPromptRunTraceContentOptions = {
 /**
  * Renders the markdown run trace of one finished or failed prompt round.
  *
- * The trace pairs the metadata of the round - which harness, model and thinking level ran it, how long each of
- * its steps took and what it cost - with the untouched runtime log, so a finished round can still be analyzed
- * after its temporary artifacts are cleaned up.
+ * The trace pairs the metadata of the round - which agent, harness, model and thinking level ran it, how long
+ * each of its steps took and what it cost - with the untouched runtime log, so a finished round can still be
+ * analyzed after its temporary artifacts are cleaned up.
  */
 export declare function buildPromptRunTraceContent(options: BuildPromptRunTraceContentOptions): string;

package/esm/scripts/run-codex-prompts/prompts/buildPromptStatusDetails.d.ts

@@ -1,11 +1,11 @@
 import { type CodexLoginMethod } from '../../../src/book-3.0/codexLoginMethod';
-import type { ThinkingLevel } from '../../../src/cli/cli-commands/coder/ThinkingLevel';
 import type { CoderRunStep, CoderRunStepKind } from '../common/CoderRunStep';
+import { type FormatRunnerSignatureOptions } from './formatRunnerSignature';
 import { type PromptRunnerAttribution } from './promptRunnerAttribution';
 /**
  * Everything one prompt status line says after its checklist marker.
  */
-export type BuildPromptStatusDetailsOptions = {
+export type BuildPromptStatusDetailsOptions = FormatRunnerSignatureOptions & {
     /**
      * Steps of the prompt round which have already finished, each with its own price and duration.
      */
@@ -14,14 +14,6 @@ export type BuildPromptStatusDetailsOptions = {
      * Step which has already started but has not finished yet, reported as `Implementation in progress`.
      */
     readonly inProgressStepKind?: CoderRunStepKind;
-    /**
-     * Harness which runs the prompt.
-     */
-    readonly runnerName: string | undefined;
-    /**
-     * Model the harness runs the prompt with.
-     */
-    readonly modelName: string | undefined;
     /**
      * Chronological runner report read from a prompt left in the middle of its implementation.
      *
@@ -37,15 +29,11 @@ export type BuildPromptStatusDetailsOptions = {
      * Authentication method the harness reported, when it is already known.
      */
     readonly loginMethod?: CodexLoginMethod;
-    /**
-     * Reasoning effort the harness runs the prompt with.
-     */
-    readonly thinkingLevel?: ThinkingLevel;
 };
 /**
  * Builds the shared body of a prompt status line, used by both the in-progress `[^]` and the done `[x]` status.
  *
  * Produces details such as
- * ``by OpenAI Codex `gpt-5.6-luna` thinking `max` (ChatGPT account) - Implementation ~$0.2036 10 minutes``.
+ * ``by Developer on OpenAI Codex `gpt-5.6-luna` thinking `max` (ChatGPT account) - Implementation ~$0.2036 10 minutes``.
  */
 export declare function buildPromptStatusDetails(options: BuildPromptStatusDetailsOptions): string;

package/esm/scripts/run-codex-prompts/prompts/formatRunnerSignature.d.ts

@@ -1,5 +1,18 @@
 import type { ThinkingLevel } from '../../../src/cli/cli-commands/coder/ThinkingLevel';
+import type { PromptRunnerMetadata } from '../common/PromptRunnerMetadata';
+/**
+ * Everything one runner signature can name, as far as it is known when the signature is formatted.
+ */
+export type FormatRunnerSignatureOptions = Partial<PromptRunnerMetadata> & {
+    /**
+     * Reasoning effort the harness runs the prompt with.
+     */
+    readonly thinkingLevel?: ThinkingLevel;
+};
 /**
  * Formats runner details for prompt status lines.
+ *
+ * Produces `` OpenAI Codex `gpt-5.6-luna` thinking `max` `` for a plain run and
+ * `` Developer on OpenAI Codex `gpt-5.6-luna` thinking `max` `` for a run personalized with `--agent`.
  */
-export declare function formatRunnerSignature(runnerName: string | undefined, modelName: string | undefined, thinkingLevel?: ThinkingLevel): string;
+export declare function formatRunnerSignature(options: FormatRunnerSignatureOptions): string;

package/esm/scripts/run-codex-prompts/prompts/markPromptFailed.d.ts

@@ -1,11 +1,12 @@
 import moment from 'moment';
+import { type FormatRunnerSignatureOptions } from './formatRunnerSignature';
 import { type PromptRunnerAttribution } from './promptRunnerAttribution';
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSection } from './types/PromptSection';
 /**
  * Input for marking one prompt section as failed.
  */
-export type MarkPromptFailedOptions = {
+export type MarkPromptFailedOptions = FormatRunnerSignatureOptions & {
     /**
      * Prompt file the marked section belongs to.
      */
@@ -14,14 +15,6 @@ export type MarkPromptFailedOptions = {
      * Section which could not be implemented.
      */
     readonly section: PromptSection;
-    /**
-     * Harness which ran the prompt.
-     */
-    readonly runnerName: string | undefined;
-    /**
-     * Model the harness ran the prompt with.
-     */
-    readonly modelName: string | undefined;
     /**
      * Chronological runner report read from a prompt left in the middle of its implementation.
      */

package/esm/src/book-2.0/agent-source/createAgentModelRequirements.deduplication.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/book-2.0/agent-source/deduplicateSystemMessage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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`
+ */
+export declare function deduplicateSystemMessage(systemMessage: string): string;

package/esm/src/book-2.0/agent-source/deduplicateSystemMessage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/cli/$initializePromptbookCliProgram.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from 'commander';
+/**
+ * Registers the CLI commands on a fresh Commander program without parsing arguments or running an action.
+ * Tests can configure output and exit handling before registration, so subcommands inherit those settings.
+ *
+ * @private internal utility of `promptbookCli`
+ */
+export declare function $initializePromptbookCliProgram(program: Command): void;

package/esm/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.114.0-34`).
+ * It follows semantic versioning (e.g., `0.114.0-37`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/cli",
-    "version": "0.114.0-35",
+    "version": "0.114.0-38",
     "description": "Promptbook: Create persistent AI agents that turn your company's scattered knowledge into action",
     "private": false,
     "sideEffects": false,
@@ -151,7 +151,6 @@
         "@sentry/nextjs": "^10.57.0",
         "@types/formidable": "3.4.7",
         "@types/mailparser": "3.4.6",
-        "@types/swagger-ui-react": "5.18.0",
         "@types/turndown": "5.0.6",
         "@vercel/blob": "1.1.1",
         "@xmldom/xmldom": "^0.9.10",
@@ -175,7 +174,7 @@
         "node-gzip": "1.1.2",
         "nodemailer": "^7.0.13",
         "qrcode": "1.5.4",
-        "swagger-ui-react": "5.31.2",
+        "swagger-ui-dist": "5.32.15",
         "turndown": "7.2.4",
         "type-fest": "4.5.0",
         "web-push": "^3.6.7",

package/src/book-2.0/agent-source/createAgentModelRequirementsWithCommitments.ts

@@ -6,6 +6,7 @@ import { applyCommitmentsToAgentModelRequirements } from './createAgentModelRequ
 import { augmentAgentModelRequirementsFromSource } from './createAgentModelRequirementsWithCommitments/augmentAgentModelRequirementsFromSource';
 import { filterCommitmentsForAgentModelRequirements } from './createAgentModelRequirementsWithCommitments/filterCommitmentsForAgentModelRequirements';
 import { materializeInlineKnowledgeSources } from './createAgentModelRequirementsWithCommitments/materializeInlineKnowledgeSources';
+import { deduplicateSystemMessage } from './deduplicateSystemMessage';
 import { parseAgentSourceWithCommitments } from './parseAgentSourceWithCommitments';
 import { removeCommentsFromSystemMessage } from './removeCommentsFromSystemMessage';
 import type { string_book } from './string_book';
@@ -73,13 +74,13 @@ function createInitialAgentModelRequirements(
  * 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: AgentModelRequirements): AgentModelRequirements {
     return {
         ...requirements,
-        systemMessage: removeCommentsFromSystemMessage(requirements.systemMessage),
+        systemMessage: deduplicateSystemMessage(removeCommentsFromSystemMessage(requirements.systemMessage)),
     };
 }

package/src/book-2.0/agent-source/deduplicateSystemMessage.ts

@@ -0,0 +1,327 @@
+/**
+ * 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/;
+
+/**
+ * One block of a system-message region, which is a group of lines surrounded by blank lines
+ *
+ * @private internal type of `deduplicateSystemMessage`
+ */
+type SystemMessageBlock = {
+    /**
+     * Exact text of the block
+     */
+    readonly text: string;
+
+    /**
+     * Whether the block opens a section occurrence merged into an earlier section with the same heading
+     */
+    readonly isOpeningMergedSection: boolean;
+};
+
+/**
+ * One region of the system message, which is either the intro before the first heading or one `## Title` section
+ *
+ * @private internal type of `deduplicateSystemMessage`
+ */
+type SystemMessageRegion = {
+    /**
+     * Case-insensitive key used to merge regions sharing one heading, `null` for the intro before the first heading
+     */
+    readonly titleKey: string | null;
+
+    /**
+     * Original heading line kept so the rendered heading preserves its exact original text
+     */
+    readonly headingLine: string | null;
+
+    /**
+     * Whether the original region separated its heading from the body by a blank line
+     */
+    readonly isBodySeparatedByBlankLine: boolean;
+
+    /**
+     * Body blocks of the region in their original order
+     */
+    readonly blocks: ReadonlyArray<SystemMessageBlock>;
+};
+
+/**
+ * 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`
+ */
+export function deduplicateSystemMessage(systemMessage: string): string {
+    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: string): ReadonlyArray<SystemMessageRegion> {
+    const regions: SystemMessageRegion[] = [];
+    let headingLine: string | null = null;
+    let bodyLines: string[] = [];
+    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: string | null, bodyLines: ReadonlyArray<string>): SystemMessageRegion {
+    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: string): string {
+    return (SYSTEM_MESSAGE_SECTION_HEADING_PATTERN.exec(headingLine)?.[1] ?? 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: ReadonlyArray<string>): ReadonlyArray<SystemMessageBlock> {
+    const blockTexts: string[] = [];
+    let blockLines: string[] = [];
+    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: ReadonlyArray<SystemMessageRegion>,
+    region: SystemMessageRegion,
+): ReadonlyArray<SystemMessageRegion> {
+    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: ReadonlyArray<SystemMessageBlock>,
+): ReadonlyArray<SystemMessageBlock> {
+    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: SystemMessageRegion): SystemMessageRegion {
+    const alreadyRenderedTexts = new Set<string>();
+    const uniqueBlocks: SystemMessageBlock[] = [];
+    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: SystemMessageRegion): string {
+    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: ReadonlyArray<SystemMessageBlock>): string {
+    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: SystemMessageBlock, nextBlock: SystemMessageBlock): string {
+    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';
+}