@promptbook/cli 0.114.0-0 → 0.114.0-2

package/src/book-2.0/book-language-documentation/renderGroupedCommitmentDocumentationMarkdown.ts

@@ -1,7 +1,12 @@
 import { spaceTrim } from 'spacetrim';
+import { parseAgentSourceWithCommitments } from '../agent-source/parseAgentSourceWithCommitments';
+import type { string_book } from '../agent-source/string_book';
+import type { BookCommitment } from '../../commitments/_base/BookCommitment';
+import { getAllCommitmentTypes } from '../../commitments/_common/getAllCommitmentTypes';
 import { getCommitmentDefinition } from '../../commitments/_common/getCommitmentDefinition';
 import type { string_markdown } from '../../types/string_markdown';
 import { shiftMarkdownHeadingLevels } from '../../utils/markdown/shiftMarkdownHeadingLevels';
+import { getSafeCodeBlock } from './getSafeCodeBlock';
 
 /**
  * Minimal commitment shape used by documentation renderers.
@@ -59,6 +64,23 @@ const CLOSED_COMMITMENT_TYPE = 'CLOSED';
  */
 const COMMITMENT_DOCUMENTATION_SECTION_HEADING_LEVEL = 2;
 
+/**
+ * Markdown code blocks whose Book source is shown as a commitment example.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+const BOOK_CODE_BLOCK_PATTERN = /(`{3,})book[^\n]*\n([\s\S]*?)\n\1/gu;
+
+/**
+ * Recognized commitment types, ordered so compound keywords take priority over
+ * their shorter prefixes when reducing an example line by line.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+const COMMITMENT_TYPES_BY_LENGTH = [...getAllCommitmentTypes()].sort(
+    (firstType, secondType) => secondType.length - firstType.length,
+);
+
 /**
  * Removes the top-level heading from one commitment documentation block.
  *
@@ -76,12 +98,18 @@ function removeLeadingTopLevelHeading(markdown: string): string {
  *
  * @param title - Heading label for the subsection.
  * @param documentation - Raw commitment documentation markdown.
+ * @param group - Commitment family represented by the documentation entry.
  * @param headingLevelShift - How many levels the whole entry is nested by its host document.
  * @returns Markdown subsection introducing one commitment of the family.
  *
  * @private internal utility of `createStandaloneBookLanguageMarkdown`
  */
-function renderDocumentationSection(title: string, documentation: string, headingLevelShift: number): string {
+function renderDocumentationSection(
+    title: string,
+    documentation: string,
+    group: GroupedCommitmentDocumentationSource,
+    headingLevelShift: number,
+): string {
     const headingPrefix = '#'.repeat(COMMITMENT_DOCUMENTATION_SECTION_HEADING_LEVEL + headingLevelShift);
 
     return spaceTrim(
@@ -90,7 +118,9 @@ function renderDocumentationSection(title: string, documentation: string, headin
 
             ${block(
                 shiftMarkdownHeadingLevels(
-                    removeLeadingTopLevelHeading(documentation) as string_markdown,
+                    removeLeadingTopLevelHeading(
+                        renderFocusedCommitmentExamples(documentation, group),
+                    ) as string_markdown,
                     headingLevelShift + 1,
                 ),
             )}
@@ -116,7 +146,10 @@ export function renderGroupedCommitmentDocumentationMarkdown(
 ): string {
     const commitmentTypes = new Set([group.primary.type, ...group.aliases]);
 
-    if (commitmentTypes.has(OPEN_COMMITMENT_TYPE) && commitmentTypes.has(CLOSED_COMMITMENT_TYPE)) {
+    const isOpenClosedCommitmentFamily =
+        commitmentTypes.has(OPEN_COMMITMENT_TYPE) && commitmentTypes.has(CLOSED_COMMITMENT_TYPE);
+
+    if (isOpenClosedCommitmentFamily) {
         const openCommitmentDefinition = getCommitmentDefinition(OPEN_COMMITMENT_TYPE);
         const closedCommitmentDefinition = getCommitmentDefinition(CLOSED_COMMITMENT_TYPE);
 
@@ -127,6 +160,7 @@ export function renderGroupedCommitmentDocumentationMarkdown(
                         renderDocumentationSection(
                             OPEN_COMMITMENT_TYPE,
                             openCommitmentDefinition.documentation,
+                            group,
                             headingLevelShift,
                         ),
                     )}
@@ -135,6 +169,7 @@ export function renderGroupedCommitmentDocumentationMarkdown(
                         renderDocumentationSection(
                             CLOSED_COMMITMENT_TYPE,
                             closedCommitmentDefinition.documentation,
+                            group,
                             headingLevelShift,
                         ),
                     )}
@@ -144,7 +179,259 @@ export function renderGroupedCommitmentDocumentationMarkdown(
     }
 
     return shiftMarkdownHeadingLevels(
-        removeLeadingTopLevelHeading(group.primary.documentation) as string_markdown,
+        removeLeadingTopLevelHeading(
+            renderFocusedCommitmentExamples(group.primary.documentation, group),
+        ) as string_markdown,
         headingLevelShift,
     );
 }
+
+/**
+ * Rewrites Book examples in commitment documentation to show one canonical
+ * commitment in isolation, with only `GOAL` and `CLOSED` as supporting syntax.
+ *
+ * @param documentation - Raw commitment documentation markdown.
+ * @param group - Commitment family represented by the documentation entry.
+ * @returns Documentation whose Book examples use focused canonical syntax.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function renderFocusedCommitmentExamples(
+    documentation: string,
+    group: GroupedCommitmentDocumentationSource,
+): string {
+    return documentation.replace(BOOK_CODE_BLOCK_PATTERN, (codeBlock, _fence, source: string) => {
+        const focusedSource = createFocusedCommitmentExampleSource(source, group);
+        return focusedSource ? getSafeCodeBlock(focusedSource, 'book') : codeBlock;
+    });
+}
+
+/**
+ * Creates a focused Book source example for one commitment documentation entry.
+ *
+ * @param source - Original Book source from the commitment documentation.
+ * @param group - Commitment family represented by the documentation entry.
+ * @returns Focused source, or `null` when the source cannot be safely reduced.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function createFocusedCommitmentExampleSource(
+    source: string,
+    group: GroupedCommitmentDocumentationSource,
+): string | null {
+    const parsedSource = parseAgentSourceWithCommitments(source as string_book);
+    const commitmentTypes = new Set([group.primary.type, ...group.aliases]);
+    const isOpenClosedCommitmentFamily =
+        commitmentTypes.has(OPEN_COMMITMENT_TYPE) && commitmentTypes.has(CLOSED_COMMITMENT_TYPE);
+    const allowedCommitmentTypes = new Set([
+        group.primary.type,
+        ...group.aliases,
+        'GOAL',
+        CLOSED_COMMITMENT_TYPE,
+    ]);
+    const canonicalTypeByCommitmentType = createCanonicalCommitmentTypeByCommitmentType(
+        group,
+        isOpenClosedCommitmentFamily,
+    );
+    const focusedCommitments = parsedSource.commitments
+        .filter((commitment) => allowedCommitmentTypes.has(commitment.type))
+        .map((commitment) => {
+            const type = canonicalTypeByCommitmentType.get(commitment.type) || commitment.type;
+            return `${type}${commitment.content ? ` ${commitment.content}` : ''}`;
+        });
+
+    if (focusedCommitments.length > 0) {
+        return finalizeFocusedCommitmentExampleSource(
+            getFocusedExampleAgentName(parsedSource.agentName),
+            focusedCommitments,
+        );
+    }
+
+    return createLineFocusedCommitmentExampleSource(source, group, isOpenClosedCommitmentFamily);
+}
+
+/**
+ * Creates a focused example when the Book parser cannot recognize the target
+ * commitment because it appears as the first source line or has a shared prefix.
+ *
+ * @param source - Original Book source from the documentation code block.
+ * @param group - Commitment family represented by the documentation entry.
+ * @param isOpenClosedCommitmentFamily - Whether the family contains both switch commitments.
+ * @returns Focused source, or `null` when the source does not use this commitment family.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function createLineFocusedCommitmentExampleSource(
+    source: string,
+    group: GroupedCommitmentDocumentationSource,
+    isOpenClosedCommitmentFamily: boolean,
+): string | null {
+    const sourceLines = source.split(/\r?\n/u);
+    const allowedCommitmentTypes = new Set([group.primary.type, ...group.aliases, 'GOAL', CLOSED_COMMITMENT_TYPE]);
+    const canonicalTypeByCommitmentType = createCanonicalCommitmentTypeByCommitmentType(
+        group,
+        isOpenClosedCommitmentFamily,
+    );
+    const focusedCommitments: Array<string> = [];
+    const firstSourceLine = sourceLines.find((line) => line.trim().length > 0) || null;
+    const firstCommitmentType = firstSourceLine ? getCommitmentTypeAtLine(firstSourceLine) : null;
+    const agentName = firstSourceLine && !firstCommitmentType ? firstSourceLine.trim() : null;
+    let activeFocusedCommitmentIndex: number | null = null;
+    let isInsideCodeBlock = false;
+
+    for (const sourceLine of sourceLines) {
+        const trimmedSourceLine = sourceLine.trim();
+
+        if (trimmedSourceLine.startsWith('```')) {
+            appendLineToActiveCommitment(focusedCommitments, activeFocusedCommitmentIndex, sourceLine);
+            isInsideCodeBlock = !isInsideCodeBlock;
+            continue;
+        }
+
+        if (isInsideCodeBlock) {
+            appendLineToActiveCommitment(focusedCommitments, activeFocusedCommitmentIndex, sourceLine);
+            continue;
+        }
+
+        const commitmentType = getCommitmentTypeAtLine(sourceLine);
+
+        if (!commitmentType) {
+            appendLineToActiveCommitment(focusedCommitments, activeFocusedCommitmentIndex, sourceLine);
+            continue;
+        }
+
+        if (!allowedCommitmentTypes.has(commitmentType)) {
+            activeFocusedCommitmentIndex = null;
+            continue;
+        }
+
+        const canonicalType = canonicalTypeByCommitmentType.get(commitmentType) || commitmentType;
+        const content = trimmedSourceLine.slice(commitmentType.length).trimStart();
+        focusedCommitments.push(`${canonicalType}${content ? ` ${content}` : ''}`);
+        activeFocusedCommitmentIndex = focusedCommitments.length - 1;
+    }
+
+    return finalizeFocusedCommitmentExampleSource(agentName, focusedCommitments);
+}
+
+/**
+ * Finds the longest supported commitment keyword at the start of a source line.
+ *
+ * @param sourceLine - One Book source line to inspect.
+ * @returns Matching commitment type, or `null` when the line is ordinary content.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function getCommitmentTypeAtLine(sourceLine: string): BookCommitment | null {
+    const trimmedSourceLine = sourceLine.trim();
+
+    return (
+        COMMITMENT_TYPES_BY_LENGTH.find(
+            (commitmentType) =>
+                trimmedSourceLine === commitmentType || trimmedSourceLine.startsWith(`${commitmentType} `),
+        ) || null
+    );
+}
+
+/**
+ * Appends a source line only when a focused commitment currently owns it.
+ *
+ * @param focusedCommitments - Focused commitments assembled from the example.
+ * @param activeFocusedCommitmentIndex - Index of the commitment receiving continuation lines.
+ * @param sourceLine - Source line to append.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function appendLineToActiveCommitment(
+    focusedCommitments: Array<string>,
+    activeFocusedCommitmentIndex: number | null,
+    sourceLine: string,
+): void {
+    if (activeFocusedCommitmentIndex === null) {
+        return;
+    }
+
+    focusedCommitments[activeFocusedCommitmentIndex] += `\n${sourceLine}`;
+}
+
+/**
+ * Adds the standard closing marker and formats one reduced Book example.
+ *
+ * @param agentName - Optional human-readable title retained from the original example.
+ * @param focusedCommitments - Canonical commitment blocks kept in the example.
+ * @returns Focused source, or `null` when no relevant commitment was found.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function finalizeFocusedCommitmentExampleSource(
+    agentName: string | null,
+    focusedCommitments: Array<string>,
+): string | null {
+    const normalizedFocusedCommitments = focusedCommitments.map((commitment) => commitment.trim());
+
+    if (normalizedFocusedCommitments.length === 0) {
+        return null;
+    }
+
+    const isClosedCommitmentIncluded = normalizedFocusedCommitments.some((commitment) =>
+        commitment.startsWith(CLOSED_COMMITMENT_TYPE),
+    );
+    const isOpenCommitmentIncluded = normalizedFocusedCommitments.some((commitment) =>
+        commitment.startsWith(OPEN_COMMITMENT_TYPE),
+    );
+
+    if (!isClosedCommitmentIncluded && !isOpenCommitmentIncluded) {
+        normalizedFocusedCommitments.push(CLOSED_COMMITMENT_TYPE);
+    }
+
+    return [agentName, ...normalizedFocusedCommitments]
+        .filter((line): line is string => Boolean(line))
+        .join('\n\n');
+}
+
+/**
+ * Keeps an example title unless the parser interpreted a commitment-only
+ * example's first line as its mandatory agent name.
+ *
+ * @param agentName - Parsed agent name from the original example.
+ * @returns Agent title suitable for a focused example, or `null` when absent.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function getFocusedExampleAgentName(agentName: string | null): string | null {
+    if (!agentName || getCommitmentDefinition(agentName as BookCommitment)) {
+        return null;
+    }
+
+    return agentName;
+}
+
+/**
+ * Maps aliases to the canonical keyword shown by a commitment example.
+ *
+ * `OPEN` and `CLOSED` share one documentation entry, but each remains a
+ * distinct keyword and must therefore retain its own spelling.
+ *
+ * @param group - Commitment family represented by the documentation entry.
+ * @param isOpenClosedCommitmentFamily - Whether the family contains both switch commitments.
+ * @returns Canonical keyword by accepted source keyword.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+function createCanonicalCommitmentTypeByCommitmentType(
+    group: GroupedCommitmentDocumentationSource,
+    isOpenClosedCommitmentFamily: boolean,
+): ReadonlyMap<string, string> {
+    const canonicalTypeByCommitmentType = new Map<string, string>();
+
+    canonicalTypeByCommitmentType.set(group.primary.type, group.primary.type);
+
+    for (const alias of group.aliases) {
+        canonicalTypeByCommitmentType.set(
+            alias,
+            isOpenClosedCommitmentFamily ? alias : group.primary.type,
+        );
+    }
+
+    return canonicalTypeByCommitmentType;
+}

package/src/book-components/Chat/utils/renderMarkdown.ts

@@ -272,6 +272,16 @@ const DETAILS_PLACEHOLDER_WRAPPED_REGEX = new RegExp(`<p>\\s*(${DETAILS_PLACEHOL
  */
 const INLINE_REFERENCE_REGEX = /\[\[([^\]\r\n]+?)\]\]/g;
 
+/**
+ * Pattern matching ordinary markdown links that can be promoted to inline reference chips.
+ *
+ * Images are intentionally captured separately and left unchanged by the replacement helper.
+ *
+ * @private utility of `renderMarkdown`
+ */
+const MARKDOWN_INLINE_REFERENCE_LINK_REGEX =
+    /(!?)\[([^\]\r\n]*)\]\(\s*(<[^>\r\n]+>|[^)\s]+)(?:\s+(?:"[^"\r\n]*"|'[^'\r\n]*'|\([^)]*\)))?\s*\)/g;
+
 /**
  * Markdown patterns that are strong enough to identify content as markdown.
  */
@@ -339,6 +349,14 @@ export type MarkdownInlineReference = {
      */
     readonly href: string;
 
+    /**
+     * Markdown link destination prefixes that should render as this reference as well.
+     *
+     * This supports legacy links such as an Agents Server project file URL while keeping
+     * `reference` as the canonical `[[project]]` token.
+     */
+    readonly sourceHrefPrefixes?: ReadonlyArray<string>;
+
     /**
      * Optional hover title for the rendered reference.
      */
@@ -699,11 +717,12 @@ const CHAT_MARKDOWN_CONVERTER = createChatMarkdownConverter();
  * outer `<details>` and optional `<summary>` markup untouched.
  *
  * @param detailsBlock - Raw `<details>...</details>` HTML captured from markdown.
+ * @param options - Markdown rendering options to reuse for the details body.
  * @returns `<details>` HTML whose body has been converted from markdown to HTML.
  *
  * @private utility of `renderMarkdown`
  */
-function renderDetailsBlock(detailsBlock: string): string_html {
+function renderDetailsBlock(detailsBlock: string, options?: RenderMarkdownOptions): string_html {
     const openTagMatch = detailsBlock.match(/^<details\b[^>]*>/i);
     const closeTagMatch = detailsBlock.match(/<\/details\s*>$/i);
 
@@ -717,7 +736,7 @@ function renderDetailsBlock(detailsBlock: string): string_html {
     const summaryMatch = innerContent.match(/^(\s*<summary\b[^>]*>[\s\S]*?<\/summary\s*>)([\s\S]*)$/i);
     const summaryHtml = summaryMatch?.[1] ?? '';
     const bodyMarkdown = (summaryMatch?.[2] ?? innerContent) as string_markdown;
-    const renderedBody = renderMarkdown(bodyMarkdown);
+    const renderedBody = renderMarkdown(bodyMarkdown, options);
 
     return `${openTag}${summaryHtml}${renderedBody}${closeTag}` as string_html;
 }
@@ -761,17 +780,18 @@ function maskMarkdownCodeSegments(markdown: string_markdown): MaskedCodeSegments
  * processes their content.
  *
  * @param markdown - Markdown text that may contain raw HTML `<details>` blocks.
+ * @param options - Markdown rendering options to reuse for the details body.
  * @returns Masked markdown and a restore helper that returns `string_html`.
  *
  * @private utility of `renderMarkdown`
  */
-function maskDetailsBlocks(markdown: string_markdown): MaskedDetailsBlocksResult {
+function maskDetailsBlocks(markdown: string_markdown, options?: RenderMarkdownOptions): MaskedDetailsBlocksResult {
     const blocks: string_html[] = [];
 
     DETAILS_BLOCK_REGEX.lastIndex = 0;
     const masked = markdown.replace(DETAILS_BLOCK_REGEX, (match) => {
         const placeholder = `${DETAILS_PLACEHOLDER_PREFIX}${blocks.length}__`;
-        blocks.push(renderDetailsBlock(match));
+        blocks.push(renderDetailsBlock(match, options));
         return placeholder;
     }) as string_markdown;
 
@@ -885,6 +905,93 @@ function createMarkdownInlineReferenceByKey(
     return referenceByKey;
 }
 
+/**
+ * Returns whether a href starts with a configured source href prefix.
+ *
+ * @param href - Markdown link destination.
+ * @param sourceHrefPrefix - Configured source href prefix.
+ * @returns Whether the href belongs to the source prefix.
+ *
+ * @private utility of `renderMarkdown`
+ */
+function doesHrefStartWithSourceHrefPrefix(href: string, sourceHrefPrefix: string): boolean {
+    if (href === sourceHrefPrefix) {
+        return true;
+    }
+
+    const normalizedSourceHrefPrefix = sourceHrefPrefix.endsWith('/') ? sourceHrefPrefix : `${sourceHrefPrefix}/`;
+
+    return href.startsWith(normalizedSourceHrefPrefix);
+}
+
+/**
+ * Returns a comparable path for an absolute href when the configured source prefix is relative.
+ *
+ * @param href - Href to normalize.
+ * @returns Absolute URL pathname or the original href when it is relative/invalid.
+ *
+ * @private utility of `renderMarkdown`
+ */
+function resolveAbsoluteHrefPath(href: string): string {
+    try {
+        return new URL(href).pathname;
+    } catch {
+        return href;
+    }
+}
+
+/**
+ * Returns whether one markdown link destination belongs to one inline reference.
+ *
+ * Relative project paths also match absolute URLs on the current server, which keeps
+ * server-generated relative links and model-generated absolute links consistent.
+ *
+ * @param reference - Candidate inline reference.
+ * @param href - Markdown link destination.
+ * @returns Whether the href should render as the reference chip.
+ *
+ * @private utility of `renderMarkdown`
+ */
+function doesMarkdownInlineReferenceMatchHref(reference: MarkdownInlineReference, href: string): boolean {
+    const normalizedHref = href.trim();
+
+    return (reference.sourceHrefPrefixes || []).some((sourceHrefPrefix) => {
+        const normalizedSourceHrefPrefix = sourceHrefPrefix.trim();
+        if (!normalizedSourceHrefPrefix) {
+            return false;
+        }
+
+        if (doesHrefStartWithSourceHrefPrefix(normalizedHref, normalizedSourceHrefPrefix)) {
+            return true;
+        }
+
+        const isRelativeSourceHrefPrefix = !/^[a-z][a-z0-9+.-]*:/i.test(normalizedSourceHrefPrefix);
+        const isAbsoluteHref = /^[a-z][a-z0-9+.-]*:/i.test(normalizedHref);
+
+        return (
+            isRelativeSourceHrefPrefix &&
+            isAbsoluteHref &&
+            doesHrefStartWithSourceHrefPrefix(resolveAbsoluteHrefPath(normalizedHref), normalizedSourceHrefPrefix)
+        );
+    });
+}
+
+/**
+ * Finds the inline reference represented by a markdown link destination.
+ *
+ * @param references - Inline references available to the markdown renderer.
+ * @param href - Markdown link destination.
+ * @returns Matching reference or `undefined` when the href is unrelated.
+ *
+ * @private utility of `renderMarkdown`
+ */
+function findMarkdownInlineReferenceByHref(
+    references: ReadonlyArray<MarkdownInlineReference>,
+    href: string,
+): MarkdownInlineReference | undefined {
+    return references.find((reference) => doesMarkdownInlineReferenceMatchHref(reference, href));
+}
+
 /**
  * Renders one inline reference as raw HTML that is sanitized by the shared markdown sanitizer.
  *
@@ -977,11 +1084,28 @@ function applyMarkdownInlineReferences(markdown: string_markdown, options?: Rend
         return markdown;
     }
 
-    return markdown.replace(INLINE_REFERENCE_REGEX, (match, rawReference: string) => {
-        const reference = referenceByKey.get(normalizeMarkdownInlineReferenceKey(rawReference));
+    const markdownWithInlineReferenceTokens = markdown.replace(
+        INLINE_REFERENCE_REGEX,
+        (match, rawReference: string) => {
+            const reference = referenceByKey.get(normalizeMarkdownInlineReferenceKey(rawReference));
 
-        return reference ? renderMarkdownInlineReferenceHtml(reference, className) : match;
-    }) as string_markdown;
+            return reference ? renderMarkdownInlineReferenceHtml(reference, className) : match;
+        },
+    );
+
+    return markdownWithInlineReferenceTokens.replace(
+        MARKDOWN_INLINE_REFERENCE_LINK_REGEX,
+        (match, imageMarker: string, _linkLabel: string, rawHref: string) => {
+            if (imageMarker) {
+                return match;
+            }
+
+            const href = rawHref.replace(/^<|>$/g, '');
+            const reference = findMarkdownInlineReferenceByHref(references, href);
+
+            return reference ? renderMarkdownInlineReferenceHtml(reference, className) : match;
+        },
+    ) as string_markdown;
 }
 
 /**
@@ -1026,7 +1150,7 @@ export function renderMarkdown(markdown: string_markdown, options?: RenderMarkdo
 
     try {
         const normalizedMarkdown = normalizeMarkdownSublists(markdown);
-        const { masked: maskedMarkdown, restore: restoreDetails } = maskDetailsBlocks(normalizedMarkdown);
+        const { masked: maskedMarkdown, restore: restoreDetails } = maskDetailsBlocks(normalizedMarkdown, options);
         const { masked: codeMaskedMarkdown, restore: restoreCode } = maskMarkdownCodeSegments(maskedMarkdown);
         const referencedMarkdown = applyMarkdownInlineReferences(codeMaskedMarkdown, options);
         const inlineReferenceMarkdown = restoreCode(referencedMarkdown);

package/src/cli/cli-commands/agents-server/startAgentsServer/createLocalAgentRunOptions.ts

@@ -25,5 +25,6 @@ export function createLocalAgentRunOptions(
         autoClone: false,
         maxMessageProcessingFailures: localAgentRunnerLimits.maxFailedAttempts,
         maxParallelMessages: localAgentRunnerLimits.maxParallelMessages,
+        isMachineReadableProgressEnabled: true,
     };
 }