@promptbook/cli 0.114.0-35 → 0.114.0-38

package/src/version.ts

@@ -16,11 +16,11 @@ export const BOOK_LANGUAGE_VERSION: string_semantic_version = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-35';
+export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-38';
 
 /**
  * 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/src/versions.txt

@@ -1211,3 +1211,6 @@
 0.114.0-33
 0.114.0-34
 0.114.0-35
+0.114.0-36
+0.114.0-37
+0.114.0-38

package/umd/index.umd.js

@@ -58,12 +58,42 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-35';
+    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-38';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
+    /**
+     * This error type indicates that you try to use a feature that is not available in the current environment
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class EnvironmentMismatchError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'EnvironmentMismatchError';
+            Object.setPrototypeOf(this, EnvironmentMismatchError.prototype);
+        }
+    }
+
+    /**
+     * Detects if the code is running in a Node.js environment
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function $isRunningInNode() {
+        try {
+            return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    // TODO: [🎺]
+
     /**
      * Trims string from all 4 sides
      *
@@ -1448,36 +1478,6 @@
      * TODO: [🧠][🧜‍♂️] Maybe join remoteServerUrl and path into single value
      */
 
-    /**
-     * This error type indicates that you try to use a feature that is not available in the current environment
-     *
-     * @public exported from `@promptbook/core`
-     */
-    class EnvironmentMismatchError extends Error {
-        constructor(message) {
-            super(message);
-            this.name = 'EnvironmentMismatchError';
-            Object.setPrototypeOf(this, EnvironmentMismatchError.prototype);
-        }
-    }
-
-    /**
-     * Detects if the code is running in a Node.js environment
-     *
-     * Note: `$` is used to indicate that this function is not a pure function - it looks at the global object to determine the environment
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function $isRunningInNode() {
-        try {
-            return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    // TODO: [🎺]
-
     /**
      * Detects if the code is running in a browser environment in main thread (Not in a web worker)
      *
@@ -39284,6 +39284,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
@@ -39357,14 +39596,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)),
         };
     }
 
@@ -58711,6 +58950,43 @@
         'start-agents-server': 'Use `ptbk agents-server start` instead.',
         'start-pipelines-server': OLD_PIPELINE_SYSTEM_DEPRECATION_MESSAGE,
     };
+    /**
+     * 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`
+     */
+    function $initializePromptbookCliProgram(program) {
+        program.name('promptbook');
+        program.alias('ptbk');
+        program.version(PROMPTBOOK_ENGINE_VERSION);
+        program.description(CLAIM);
+        // Commands are listed in registration order. Keep `coder` first and hide deprecated commands below.
+        $initializeCoderCommand(program);
+        $initializeAgentCommand(program);
+        $initializeAgentFolderCommand(program);
+        $initializeAgentsServerCommand(program);
+        $initializeAboutCommand(program);
+        $initializeHelloCommand(program);
+        $initializeRunCommand(program);
+        $initializeLoginCommand(program);
+        $initializeMakeCommand(program);
+        $initializePrettifyCommand(program);
+        $initializeTestCommand(program);
+        $initializeListModelsCommand(program);
+        $initializeListScrapersCommand(program);
+        $initializeStartAgentsServerCommand(program);
+        $initializeStartPipelinesServerCommand(program);
+        for (const command of program.commands) {
+            const deprecationMessage = DEPRECATED_TOP_LEVEL_COMMAND_MESSAGES[command.name()];
+            if (deprecationMessage !== undefined) {
+                $deprecateCliCommand(command, deprecationMessage);
+            }
+        }
+        program.commands.forEach($addGlobalOptionsToCommand);
+    }
+    // Note: [🟡] Code for CLI command registration [$initializePromptbookCliProgram](src/cli/$initializePromptbookCliProgram.ts) should never be published outside of `@promptbook/cli`
+
     /**
      * Raw top-level CLI arguments that print the Promptbook version.
      *
@@ -58743,32 +59019,7 @@
             console.info(colors__default["default"].gray(`Promptbook CLI version ${PROMPTBOOK_ENGINE_VERSION} in ${__filename.split('\\').join('/')}`));
         }
         const program = new commander__default["default"].Command();
-        program.name('promptbook');
-        program.alias('ptbk');
-        program.version(PROMPTBOOK_ENGINE_VERSION);
-        program.description(CLAIM);
-        // Note: These options are valid for all commands
-        // Note: Commands are listed in the help in the order they are registered,
-        //       `coder` is the most used one so it goes first and the deprecated ones,
-        //       which `$deprecateTopLevelCommands` hides from the help entirely, go last
-        $initializeCoderCommand(program);
-        $initializeAgentCommand(program);
-        $initializeAgentFolderCommand(program);
-        $initializeAgentsServerCommand(program);
-        $initializeAboutCommand(program);
-        $initializeHelloCommand(program);
-        $initializeRunCommand(program);
-        $initializeLoginCommand(program);
-        $initializeMakeCommand(program);
-        $initializePrettifyCommand(program);
-        $initializeTestCommand(program);
-        $initializeListModelsCommand(program);
-        $initializeListScrapersCommand(program);
-        $initializeStartAgentsServerCommand(program);
-        $initializeStartPipelinesServerCommand(program);
-        $deprecateTopLevelCommands(program);
-        // TODO: [🧠] Should it be here or not> $addGlobalOptionsToCommand(program);
-        program.commands.forEach($addGlobalOptionsToCommand);
+        $initializePromptbookCliProgram(program);
         // Note: There is no default command, so `ptbk` without a subcommand asks for one
         //       instead of running the deprecated `ptbk run`
         if (commandLineArguments.length === 0) {
@@ -58785,17 +59036,6 @@
         const firstCommandLineArgument = commandLineArguments[0];
         return firstCommandLineArgument !== undefined && VERSION_OPTION_ARGUMENTS.has(firstCommandLineArgument);
     }
-    /**
-     * Marks each configured top-level legacy command as deprecated, which keeps it usable but takes it out of the help.
-     */
-    function $deprecateTopLevelCommands(program) {
-        for (const command of program.commands) {
-            const deprecationMessage = DEPRECATED_TOP_LEVEL_COMMAND_MESSAGES[command.name()];
-            if (deprecationMessage !== undefined) {
-                $deprecateCliCommand(command, deprecationMessage);
-            }
-        }
-    }
     // Note: [🟡] Code for CLI program [promptbookCli](src/cli/promptbookCli.ts) should never be published outside of `@promptbook/cli`
     // TODO: [🥠] Do not export, its just for CLI script
     // TODO: [🕌] When more functionalities, rename
@@ -75620,13 +75860,16 @@
             }
             throw error;
         }));
+        // Note: Parsed once here, because both the display name of the agent and its routing references need it
+        const parsedAgentSource = parseAgentSource(agentSource);
         return {
             agentSource,
+            agentName: parsedAgentSource.meta.fullname || parsedAgentSource.agentName,
             agentReferences: createCoderAgentReferences({
                 agentBookReference: normalizedAgentBookReference,
                 resolvedAgentBookPath,
                 currentWorkingDirectory,
-                agentSource,
+                normalizedAgentNameFromBook: parsedAgentSource.agentName,
             }),
         };
     }
@@ -75654,13 +75897,12 @@
         const relativeAgentBookPath = path.relative(options.currentWorkingDirectory, options.resolvedAgentBookPath).replaceAll('\\', '/');
         const agentBookFileName = path.basename(options.resolvedAgentBookPath);
         const agentBookName = path.basename(options.resolvedAgentBookPath, path.extname(options.resolvedAgentBookPath));
-        const agentNameFromBook = parseAgentSource(options.agentSource).agentName;
         return Array.from(new Set([
             options.agentBookReference,
             relativeAgentBookPath,
             agentBookFileName,
             agentBookName,
-            agentNameFromBook,
+            options.normalizedAgentNameFromBook,
         ].filter((agentReference) => agentReference.trim() !== '')));
     }
 
@@ -75923,11 +76165,27 @@
 
     /**
      * 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`.
+     */
+    function formatRunnerSignature(options) {
+        var _a;
+        const normalizedAgentName = (_a = options.agentName) === null || _a === void 0 ? void 0 : _a.trim();
+        const harnessSignature = formatHarnessSignature(options);
+        if (!normalizedAgentName) {
+            return harnessSignature;
+        }
+        return `${normalizedAgentName} on ${harnessSignature}`;
+    }
+    /**
+     * Formats the harness part of one runner signature, which names the harness, its model and its thinking level.
      */
-    function formatRunnerSignature(runnerName, modelName, thinkingLevel) {
-        const normalizedRunner = runnerName === null || runnerName === void 0 ? void 0 : runnerName.trim();
-        const normalizedModel = modelName === null || modelName === void 0 ? void 0 : modelName.trim();
-        const thinkingLevelSuffix = thinkingLevel ? ` thinking \`${thinkingLevel}\`` : '';
+    function formatHarnessSignature(options) {
+        var _a, _b;
+        const normalizedRunner = (_a = options.runnerName) === null || _a === void 0 ? void 0 : _a.trim();
+        const normalizedModel = (_b = options.modelName) === null || _b === void 0 ? void 0 : _b.trim();
+        const thinkingLevelSuffix = options.thinkingLevel ? ` thinking \`${options.thinkingLevel}\`` : '';
         if (!normalizedRunner && !normalizedModel) {
             return 'unknown';
         }
@@ -75942,7 +76200,12 @@
      * Prints the compact summary of one finished `ptbk coder ping`.
      */
     function printCoderPingResult(result) {
-        const runnerSignature = formatRunnerSignature(result.runnerName, result.modelName, result.thinkingLevel);
+        // Note: `ptbk coder ping` measures one harness alone, it never runs the prompts of a Book agent
+        const runnerSignature = formatRunnerSignature({
+            runnerName: result.runnerName,
+            modelName: result.modelName,
+            thinkingLevel: result.thinkingLevel,
+        });
         const loginMethodLabel = formatCodexLoginMethod(result.loginMethod);
         const loginMethodSuffix = loginMethodLabel === undefined ? '' : ` (${loginMethodLabel})`;
         console.info(colors__default["default"].green(`🏓 ${runnerSignature}${loginMethodSuffix} answered in ${formatCoderPingResponseTime(result.durationMs)}`));
@@ -78430,11 +78693,11 @@
      * 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``.
      */
     function buildPromptStatusDetails(options) {
-        const { steps, inProgressStepKind, runnerName, modelName, previousRunnerSignatures, attemptCount, loginMethod, thinkingLevel, } = options;
-        const runnerSignature = formatRunnerSignature(runnerName, modelName, thinkingLevel);
+        const { steps, inProgressStepKind, previousRunnerSignatures, attemptCount, loginMethod } = options;
+        const runnerSignature = formatRunnerSignature(options);
         const attemptMetadata = formatPromptAttemptMetadata('done', attemptCount);
         const loginMethodLabel = formatCodexLoginMethod(loginMethod);
         const loginMethodSuffix = loginMethodLabel ? ` (${loginMethodLabel})` : '';
@@ -78546,9 +78809,9 @@
      * Marks a prompt section as failed and records runner details.
      */
     function markPromptFailed(options) {
-        const { file, section, runnerName, modelName, previousRunnerSignatures, promptExecutionStartedDate, attemptCount } = options;
+        const { file, section, previousRunnerSignatures, promptExecutionStartedDate, attemptCount } = options;
         const attribution = formatPromptRunnerAttribution({
-            currentRunnerSignature: formatRunnerSignature(runnerName, modelName),
+            currentRunnerSignature: formatRunnerSignature(options),
             previousRunnerSignatures,
         });
         const attemptMetadata = formatPromptAttemptMetadata('failed', attemptCount);
@@ -78634,9 +78897,9 @@
     /**
      * 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.
      */
     function buildPromptRunTraceContent(options) {
         const sections = [
@@ -78651,7 +78914,7 @@
      */
     function buildPromptRunTraceSummarySection(options) {
         const { file, section, outcome } = options;
-        const runnerSignature = formatRunnerSignature(options.runnerName, options.modelName, options.thinkingLevel);
+        const runnerSignature = formatRunnerSignature(options);
         const loginMethodLabel = outcome.kind === 'succeeded' ? formatCodexLoginMethod(outcome.loginMethod) : undefined;
         const loginMethodSuffix = loginMethodLabel ? ` (${loginMethodLabel})` : '';
         const detailLines = [
@@ -78961,8 +79224,7 @@
             section: nextPrompt.section,
             steps: progress.finishedSteps,
             inProgressStepKind: progress.startedStepKind,
-            runnerName: runnerMetadata.runnerName,
-            modelName: runnerMetadata.modelName,
+            ...runnerMetadata,
             previousRunnerSignatures,
             attemptCount,
             loginMethod: progress.loginMethod,
@@ -79032,8 +79294,7 @@
             file: nextPrompt.file,
             section: nextPrompt.section,
             steps: result.steps,
-            runnerName: runnerMetadata.runnerName,
-            modelName: runnerMetadata.modelName,
+            ...runnerMetadata,
             previousRunnerSignatures,
             attemptCount: result.attemptCount,
             loginMethod: result.loginMethod,
@@ -79112,8 +79373,7 @@
         markPromptFailed({
             file: nextPrompt.file,
             section: nextPrompt.section,
-            runnerName: runnerMetadata.runnerName,
-            modelName: runnerMetadata.modelName,
+            ...runnerMetadata,
             previousRunnerSignatures,
             promptExecutionStartedDate,
             attemptCount,
@@ -79143,16 +79403,15 @@
      * Persists the run trace of one prompt round, so the round can still be analyzed after its temporary
      * artifacts are gone.
      *
-     * This is the single place where both the successful and the failed round record what they did, which harness,
-     * model and thinking level did it and everything that harness has written while doing it.
+     * This is the single place where both the successful and the failed round record what they did, which agent,
+     * harness, model and thinking level did it and everything that harness has written while doing it.
      */
     async function recordPromptRoundTrace(options) {
         const { options: runOptions, nextPrompt, runnerMetadata, promptExecutionStartedDate, attemptCount, logPath, outcome, } = options;
         await writePromptRunTrace({
             file: nextPrompt.file,
             section: nextPrompt.section,
-            runnerName: runnerMetadata.runnerName,
-            modelName: runnerMetadata.modelName,
+            ...runnerMetadata,
             thinkingLevel: runOptions.thinkingLevel,
             testCommand: runOptions.testCommand,
             attemptCount,
@@ -80116,7 +80375,13 @@
             if (await runDryRunIfRequested(options)) {
                 return;
             }
-            const { runner, actualRunnerModel, runnerMetadata } = resolvePromptRunner(options);
+            const { runner, actualRunnerModel, runnerMetadata: harnessRunnerMetadata } = resolvePromptRunner(options);
+            // Note: The harness only knows itself, so the Book agent it runs as is joined here - this is the single
+            //       place where the whole run report of prompt status lines and run traces is put together
+            const runnerMetadata = {
+                ...harnessRunnerMetadata,
+                agentName: resolvedCoderAgent === null || resolvedCoderAgent === void 0 ? void 0 : resolvedCoderAgent.agentName,
+            };
             const promptRunnerIdentity = {
                 harnessName: options.agentName,
                 modelName: actualRunnerModel,