@promptbook/cli 0.114.0-34 → 0.114.0-38

package/esm/index.es.js

@@ -48,12 +48,42 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.114.0-34';
+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
  *
@@ -1438,36 +1468,6 @@ true);
  * 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)
  *
@@ -39274,6 +39274,245 @@ function stripInlineKnowledgeMetadata(metadata) {
     return Object.keys(rest).length > 0 ? rest : undefined;
 }
 
+/**
+ * Pattern matching a markdown section heading (`## Title`) that separates system-message sections
+ *
+ * @private internal constant of `deduplicateSystemMessage`
+ */
+const SYSTEM_MESSAGE_SECTION_HEADING_PATTERN = /^##(?!#)\s*(.+?)\s*$/;
+/**
+ * Pattern matching a fenced code block delimiter which suspends section and block splitting
+ *
+ * @private internal constant of `deduplicateSystemMessage`
+ */
+const CODE_FENCE_PATTERN = /^\s*(?:```|~~~)/;
+/**
+ * Pattern matching a markdown list item which keeps merged bullet lists visually compact
+ *
+ * @private internal constant of `deduplicateSystemMessage`
+ */
+const LIST_ITEM_PATTERN = /^\s*(?:[-*+]|\d+[.)])\s/;
+/**
+ * Removes duplicated instructions from a generated system message
+ *
+ * Commitments are applied one by one, so a commitment used multiple times in one book repeats its whole
+ * section, including the shared guidance preamble. For example two `WRITING RULES` commitments emit the
+ * `## Writing rules` heading and its guidance paragraph twice. This function merges all sections sharing
+ * one heading into the position of their first occurrence and keeps every identical block only once.
+ *
+ * @param systemMessage The assembled system message which may contain repeated sections and blocks
+ * @returns The system message where each section heading and each identical block appears exactly once
+ *
+ * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ */
+function deduplicateSystemMessage(systemMessage) {
+    if (!systemMessage.trim()) {
+        return systemMessage;
+    }
+    return splitSystemMessageIntoRegions(systemMessage)
+        .reduce(mergeRegionSharingHeading, [])
+        .map(removeDuplicateBlocksFromRegion)
+        .map(renderRegion)
+        .filter((renderedRegion) => renderedRegion !== '')
+        .join('\n\n');
+}
+/**
+ * Splits the system message into the intro region and one region per `## Title` section
+ *
+ * @param systemMessage The system message to split
+ * @returns Regions in their original order, without empty ones
+ *
+ * @private internal utility of `deduplicateSystemMessage`
+ */
+function splitSystemMessageIntoRegions(systemMessage) {
+    const regions = [];
+    let headingLine = null;
+    let bodyLines = [];
+    let isInsideCodeFence = false;
+    for (const line of systemMessage.split(/\r?\n/)) {
+        if (CODE_FENCE_PATTERN.test(line)) {
+            isInsideCodeFence = !isInsideCodeFence;
+        }
+        if (isInsideCodeFence || !SYSTEM_MESSAGE_SECTION_HEADING_PATTERN.test(line)) {
+            bodyLines.push(line);
+            continue;
+        }
+        regions.push(createRegion(headingLine, bodyLines));
+        headingLine = line;
+        bodyLines = [];
+    }
+    regions.push(createRegion(headingLine, bodyLines));
+    return regions.filter((region) => region.headingLine !== null || region.blocks.length > 0);
+}
+/**
+ * Creates one region from its heading line and its raw body lines
+ *
+ * @param headingLine The original `## Title` line, or `null` for the intro before the first heading
+ * @param bodyLines The raw lines following the heading line
+ * @returns The region with its body already split into blocks
+ *
+ * @private internal utility of `splitSystemMessageIntoRegions`
+ */
+function createRegion(headingLine, bodyLines) {
+    return {
+        titleKey: headingLine === null ? null : normalizeSectionTitle(headingLine),
+        headingLine,
+        isBodySeparatedByBlankLine: bodyLines[0] !== undefined && bodyLines[0].trim() === '',
+        blocks: splitBodyIntoBlocks(bodyLines),
+    };
+}
+/**
+ * Normalizes a heading line into a key usable for matching sections which belong together
+ *
+ * @param headingLine The original `## Title` line
+ * @returns Lowercased title without the markdown heading prefix
+ *
+ * @private internal utility of `createRegion`
+ */
+function normalizeSectionTitle(headingLine) {
+    var _a, _b;
+    return ((_b = (_a = SYSTEM_MESSAGE_SECTION_HEADING_PATTERN.exec(headingLine)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : headingLine).toLowerCase();
+}
+/**
+ * Splits raw body lines into blocks separated by blank lines while keeping fenced code blocks intact
+ *
+ * @param bodyLines The raw lines of one region body
+ * @returns Non-empty blocks in their original order
+ *
+ * @private internal utility of `createRegion`
+ */
+function splitBodyIntoBlocks(bodyLines) {
+    const blockTexts = [];
+    let blockLines = [];
+    let isInsideCodeFence = false;
+    for (const line of bodyLines) {
+        if (CODE_FENCE_PATTERN.test(line)) {
+            isInsideCodeFence = !isInsideCodeFence;
+        }
+        if (!isInsideCodeFence && line.trim() === '') {
+            blockTexts.push(blockLines.join('\n'));
+            blockLines = [];
+            continue;
+        }
+        blockLines.push(line);
+    }
+    blockTexts.push(blockLines.join('\n'));
+    return blockTexts
+        .filter((blockText) => blockText.trim() !== '')
+        .map((blockText) => ({ text: blockText, isOpeningMergedSection: false }));
+}
+/**
+ * Appends one region to the already merged regions, merging it into an earlier region with the same heading
+ *
+ * @param mergedRegions Regions merged so far, used as the reducer accumulator
+ * @param region The next region in original order
+ * @returns The accumulator with the region either appended or merged into its earlier twin
+ *
+ * @private internal utility of `deduplicateSystemMessage`
+ */
+function mergeRegionSharingHeading(mergedRegions, region) {
+    const existingRegionIndex = mergedRegions.findIndex((mergedRegion) => region.titleKey !== null && mergedRegion.titleKey === region.titleKey);
+    if (existingRegionIndex === -1) {
+        return [...mergedRegions, region];
+    }
+    return mergedRegions.map((mergedRegion, index) => index !== existingRegionIndex
+        ? mergedRegion
+        : {
+            ...mergedRegion,
+            blocks: [...mergedRegion.blocks, ...markFirstBlockAsOpeningMergedSection(region.blocks)],
+        });
+}
+/**
+ * Marks the first block of a merged section occurrence so the merge seam can be rendered as one list
+ *
+ * @param blocks The blocks of the section occurrence being merged into an earlier section
+ * @returns The same blocks with the first one marked as opening a merged section
+ *
+ * @private internal utility of `mergeRegionSharingHeading`
+ */
+function markFirstBlockAsOpeningMergedSection(blocks) {
+    return blocks.map((block, index) => (index === 0 ? { ...block, isOpeningMergedSection: true } : block));
+}
+/**
+ * Keeps only the first occurrence of every identical block inside one region
+ *
+ * @param region The region whose blocks may repeat
+ * @returns The region without repeated blocks
+ *
+ * @private internal utility of `deduplicateSystemMessage`
+ */
+function removeDuplicateBlocksFromRegion(region) {
+    const alreadyRenderedTexts = new Set();
+    const uniqueBlocks = [];
+    let isMergeSeamPending = false;
+    for (const block of region.blocks) {
+        if (alreadyRenderedTexts.has(block.text)) {
+            // Note: A removed block must still hand its merge seam over to the next block which survives
+            isMergeSeamPending = isMergeSeamPending || block.isOpeningMergedSection;
+            continue;
+        }
+        alreadyRenderedTexts.add(block.text);
+        uniqueBlocks.push({
+            text: block.text,
+            isOpeningMergedSection: block.isOpeningMergedSection || isMergeSeamPending,
+        });
+        isMergeSeamPending = false;
+    }
+    return { ...region, blocks: uniqueBlocks };
+}
+/**
+ * Renders one region back into its markdown representation
+ *
+ * @param region The region to render
+ * @returns The heading line together with its joined blocks
+ *
+ * @private internal utility of `deduplicateSystemMessage`
+ */
+function renderRegion(region) {
+    const body = joinBlocks(region.blocks);
+    if (region.headingLine === null) {
+        return body;
+    }
+    if (body === '') {
+        return region.headingLine;
+    }
+    return `${region.headingLine}${region.isBodySeparatedByBlankLine ? '\n\n' : '\n'}${body}`;
+}
+/**
+ * Joins blocks of one region back together
+ *
+ * @param blocks The blocks to join in their original order
+ * @returns The joined body of one region
+ *
+ * @private internal utility of `renderRegion`
+ */
+function joinBlocks(blocks) {
+    return blocks
+        .map((block, index) => index === 0 ? block.text : `${createBlockSeparator(blocks[index - 1], block)}${block.text}`)
+        .join('');
+}
+/**
+ * Chooses the separator between two neighboring blocks
+ *
+ * Blocks are normally separated by a blank line, exactly as they were written. Only where two sections were
+ * merged together their lists are joined into one compact list instead of two separate ones.
+ *
+ * @param previousBlock The block rendered before the separator
+ * @param nextBlock The block rendered after the separator
+ * @returns Either a single or a double newline
+ *
+ * @private internal utility of `joinBlocks`
+ */
+function createBlockSeparator(previousBlock, nextBlock) {
+    if (!nextBlock.isOpeningMergedSection) {
+        return '\n\n';
+    }
+    const previousBlockLines = previousBlock.text.split('\n');
+    const isListContinuing = LIST_ITEM_PATTERN.test(previousBlockLines[previousBlockLines.length - 1]) &&
+        LIST_ITEM_PATTERN.test(nextBlock.text.split('\n')[0]);
+    return isListContinuing ? '\n' : '\n\n';
+}
+
 /**
  * Removes single-hash comment lines (`# Comment`) from a system message
  * This is used to clean up the final system message before sending it to the AI model
@@ -39347,14 +39586,14 @@ function createInitialAgentModelRequirements(agentName, modelName) {
  * Performs the final system-message cleanup pass after all other augmentation steps are complete.
  *
  * @param requirements - Fully built requirements before final cleanup.
- * @returns Requirements with comment lines removed from the final system message.
+ * @returns Requirements with comment lines removed and repeated instructions deduplicated in the final system message.
  *
  * @private internal utility of `createAgentModelRequirementsWithCommitments`
  */
 function finalizeRequirements(requirements) {
     return {
         ...requirements,
-        systemMessage: removeCommentsFromSystemMessage(requirements.systemMessage),
+        systemMessage: deduplicateSystemMessage(removeCommentsFromSystemMessage(requirements.systemMessage)),
     };
 }
 
@@ -58701,6 +58940,43 @@ const DEPRECATED_TOP_LEVEL_COMMAND_MESSAGES = {
     '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.
  *
@@ -58733,32 +59009,7 @@ async function promptbookCli() {
         console.info(colors.gray(`Promptbook CLI version ${PROMPTBOOK_ENGINE_VERSION} in ${__filename.split('\\').join('/')}`));
     }
     const program = new commander.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) {
@@ -58775,17 +59026,6 @@ function isTopLevelVersionRequested(commandLineArguments) {
     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
@@ -75610,13 +75850,16 @@ async function resolveCoderAgentBook(agentBookReference, currentWorkingDirectory
         }
         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,
         }),
     };
 }
@@ -75644,13 +75887,12 @@ function createCoderAgentReferences(options) {
     const relativeAgentBookPath = relative(options.currentWorkingDirectory, options.resolvedAgentBookPath).replaceAll('\\', '/');
     const agentBookFileName = basename(options.resolvedAgentBookPath);
     const agentBookName = basename(options.resolvedAgentBookPath, 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() !== '')));
 }
 
@@ -75913,11 +76155,27 @@ function formatUsagePrice(usage) {
 
 /**
  * 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';
     }
@@ -75932,7 +76190,12 @@ function formatRunnerSignature(runnerName, modelName, thinkingLevel) {
  * 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.green(`🏓 ${runnerSignature}${loginMethodSuffix} answered in ${formatCoderPingResponseTime(result.durationMs)}`));
@@ -78420,11 +78683,11 @@ function toPromptRunnerAttribution(runnerSignatures) {
  * 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})` : '';
@@ -78536,9 +78799,9 @@ function markPromptDone(options) {
  * 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);
@@ -78624,9 +78887,9 @@ function getSafeCodeBlock(content, language = 'markdown') {
 /**
  * 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 = [
@@ -78641,7 +78904,7 @@ function buildPromptRunTraceContent(options) {
  */
 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 = [
@@ -78951,8 +79214,7 @@ async function recordPromptRoundInProgress(options) {
         section: nextPrompt.section,
         steps: progress.finishedSteps,
         inProgressStepKind: progress.startedStepKind,
-        runnerName: runnerMetadata.runnerName,
-        modelName: runnerMetadata.modelName,
+        ...runnerMetadata,
         previousRunnerSignatures,
         attemptCount,
         loginMethod: progress.loginMethod,
@@ -79022,8 +79284,7 @@ async function finalizeSuccessfulPromptRound(options) {
         file: nextPrompt.file,
         section: nextPrompt.section,
         steps: result.steps,
-        runnerName: runnerMetadata.runnerName,
-        modelName: runnerMetadata.modelName,
+        ...runnerMetadata,
         previousRunnerSignatures,
         attemptCount: result.attemptCount,
         loginMethod: result.loginMethod,
@@ -79102,8 +79363,7 @@ async function finalizeFailedPromptRound(options) {
     markPromptFailed({
         file: nextPrompt.file,
         section: nextPrompt.section,
-        runnerName: runnerMetadata.runnerName,
-        modelName: runnerMetadata.modelName,
+        ...runnerMetadata,
         previousRunnerSignatures,
         promptExecutionStartedDate,
         attemptCount,
@@ -79133,16 +79393,15 @@ async function finalizeFailedPromptRound(options) {
  * 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,
@@ -80106,7 +80365,13 @@ async function runCodexPrompts(providedOptions) {
         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,