@promptbook/cli 0.114.0-1 → 0.114.0-3

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

@@ -9,6 +9,7 @@ import type { Converter as ShowdownConverter } from 'showdown';
 import showdown from 'showdown';
 import type { string_html, string_markdown } from '../../../types/string_markdown';
 import { TODO_USE } from '../../../utils/organization/TODO_USE';
+import { $provideServerDomWindow } from './$provideServerDomWindow';
 import { createCitationMarkerRegex, parseCitationMarker } from './parseCitationMarker';
 
 /**
@@ -218,13 +219,6 @@ let browserMarkdownSanitizer: DomPurifyInstance | null = null;
  */
 let serverMarkdownSanitizer: DomPurifyInstance | null = null;
 
-/**
- * Shared JSDOM window backing the server-side DOMPurify instance.
- *
- * @private utility of `renderMarkdown`
- */
-let serverMarkdownSanitizerWindow: DomPurifyWindowLike | null = null;
-
 /**
  * Pattern matching CODE FENCE.
  */
@@ -272,6 +266,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 +343,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.
      */
@@ -528,21 +540,6 @@ function createMarkdownSanitizer(sanitizerWindow: DomPurifyWindowLike): DomPurif
     return markdownSanitizer;
 }
 
-/**
- * Lazily creates the JSDOM window used by server-side markdown sanitization.
- *
- * @private utility of `renderMarkdown`
- */
-function getServerMarkdownSanitizerWindow(): DomPurifyWindowLike {
-    if (!serverMarkdownSanitizerWindow) {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { JSDOM } = require('jsdom') as typeof import('jsdom');
-        serverMarkdownSanitizerWindow = new JSDOM('').window as unknown as DomPurifyWindowLike;
-    }
-
-    return serverMarkdownSanitizerWindow;
-}
-
 /**
  * Returns the shared DOMPurify instance appropriate for the current runtime.
  *
@@ -555,7 +552,7 @@ function getMarkdownSanitizer(): DomPurifyInstance {
         return browserMarkdownSanitizer;
     }
 
-    serverMarkdownSanitizer ??= createMarkdownSanitizer(getServerMarkdownSanitizerWindow());
+    serverMarkdownSanitizer ??= createMarkdownSanitizer($provideServerDomWindow());
 
     return serverMarkdownSanitizer;
 }
@@ -699,11 +696,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 +715,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 +759,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 +884,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 +1063,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 +1129,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/buildAgentsServer/createAgentsServerRuntimeEnvironment.ts

@@ -22,6 +22,14 @@ export const PTBK_AGENTS_SERVER_BUILD_WORKER_COUNT_ENV = 'PTBK_AGENTS_SERVER_BUI
  */
 export const PTBK_AGENTS_SERVER_IGNORE_NEXT_VALIDATION_ENV = 'PTBK_AGENTS_SERVER_IGNORE_NEXT_VALIDATION';
 
+/**
+ * Environment variable that disables throwaway webpack filesystem caches for CLI-owned production builds.
+ *
+ * @private internal constant of `buildAgentsServer`
+ */
+export const PTBK_AGENTS_SERVER_DISABLE_WEBPACK_FILESYSTEM_CACHE_ENV =
+    'PTBK_AGENTS_SERVER_DISABLE_WEBPACK_FILESYSTEM_CACHE';
+
 /**
  * Conservative Next.js build worker count used by CLI-owned Agents Server production builds.
  *
@@ -41,6 +49,7 @@ export function createAgentsServerRuntimeEnvironment(
     nodeModulesPath: string,
     options: {
         readonly isNextValidationIgnored?: boolean;
+        readonly isWebpackFilesystemCacheDisabled?: boolean;
     } = {},
 ): NodeJS.ProcessEnv {
     return {
@@ -54,6 +63,11 @@ export function createAgentsServerRuntimeEnvironment(
                   [PTBK_AGENTS_SERVER_IGNORE_NEXT_VALIDATION_ENV]: 'true',
               }
             : {}),
+        ...(options.isWebpackFilesystemCacheDisabled
+            ? {
+                  [PTBK_AGENTS_SERVER_DISABLE_WEBPACK_FILESYSTEM_CACHE_ENV]: 'true',
+              }
+            : {}),
     };
 }
 

package/src/cli/cli-commands/agents-server/buildAgentsServer/ensureAgentsServerBuild.ts

@@ -30,6 +30,7 @@ export async function ensureAgentsServerBuild(
     });
     const buildEnvironment = createAgentsServerRuntimeEnvironment(environment, preparedRuntime.nodeModulesPath, {
         isNextValidationIgnored: preparedRuntime.isAppPathMaterialized,
+        isWebpackFilesystemCacheDisabled: true,
     });
 
     if (

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,
     };
 }

package/src/cli/cli-commands/coder/add.ts

@@ -4,12 +4,18 @@ import type {
 } from 'commander';
 import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import prompts from 'prompts';
 import { spaceTrim } from 'spacetrim';
 import { NotAllowed } from '../../../errors/NotAllowed';
 import { ParseError } from '../../../errors/ParseError';
 import { normalizeToKebabCase } from '../../../utils/normalization/normalize-to-kebab-case';
 import type { $side_effect } from '../../../utils/organization/$side_effect';
+import { loadPromptsModule } from '../../common/loadPromptsModule';
+import type { CoderGitSyncCliOptions } from '../common/coderGitSyncCliOptions';
+import {
+    addCoderGitSyncOptions,
+    CODER_GIT_SYNC_DESCRIPTION,
+    normalizeCoderGitSyncCliOptions,
+} from '../common/coderGitSyncCliOptions';
 import { handleActionErrors } from '../common/handleActionErrors';
 import {
     buildCoderPromptSection,
@@ -49,15 +55,19 @@ const FALLBACK_PROMPT_SLUG = 'prompt';
 export function $initializeCoderAddCommand(program: Program): $side_effect {
     const command = program.command('add');
     command.description(
-        spaceTrim(`
-            Add one ready-to-run prompt file to the queue
+        spaceTrim(
+            (block) => `
+                Add one ready-to-run prompt file to the queue
 
-            Provide the description as an argument, pipe it through stdin, or run without arguments to type it interactively:
-            - \`ptbk coder add "some new feature"\`
-            - \`ptbk coder add --priority 1 "some new feature"\`
-            - \`ptbk coder add <<EOF ... EOF\`
-            - \`ptbk coder add\`
-        `),
+                Provide the description as an argument, pipe it through stdin, or run without arguments to type it interactively:
+                - \`ptbk coder add "some new feature"\`
+                - \`ptbk coder add --priority 1 "some new feature"\`
+                - \`ptbk coder add <<EOF ... EOF\`
+                - \`ptbk coder add\`
+
+                ${block(CODER_GIT_SYNC_DESCRIPTION)}
+            `,
+        ),
     );
 
     command.argument('[description]', 'Plain-language description of the feature or task to implement');
@@ -77,22 +87,39 @@ export function $initializeCoderAddCommand(program: Program): $side_effect {
                 .join(', ')}) or a markdown file path relative to the current project root.
         `),
     );
+    addCoderGitSyncOptions(command);
 
     command.action(
         handleActionErrors(async (descriptionArgument: string | undefined, cliOptions) => {
             const { priority, template: templateOption } = cliOptions as {
                 readonly priority: number;
                 readonly template?: string;
-            };
+            } & CoderGitSyncCliOptions;
+
+            const gitSync = normalizeCoderGitSyncCliOptions(cliOptions as CoderGitSyncCliOptions);
+            const projectPath = process.cwd();
 
             const description = await resolveCoderPromptDescription(descriptionArgument);
 
-            await addCoderPrompt({
-                projectPath: process.cwd(),
+            // Note: Import the git synchronization dynamically to keep the CLI fast for runs without `--commit`
+            const { $commitCoderChanges, $pullCoderChanges } = await import(
+                '../../../../scripts/run-codex-prompts/git/coderGitSync'
+            );
+
+            await $pullCoderChanges({ gitSync, projectPath });
+
+            const { /* filePath,*/ emojiTag } = await addCoderPrompt({
+                projectPath,
                 description,
                 priority,
                 templateOption,
             });
+
+            await $commitCoderChanges({
+                gitSync,
+                projectPath,
+                commitMessage: `${emojiTag} Add prompt`,
+            });
         }),
     );
 }
@@ -216,6 +243,7 @@ async function resolveCoderPromptDescription(descriptionArgument: string | undef
         return standardInputDescription;
     }
 
+    const { default: prompts } = await loadPromptsModule();
     const response = await prompts({
         type: 'text',
         name: 'description',

package/src/cli/cli-commands/coder/agentCodingFile.ts

@@ -1,13 +1,5 @@
 import { spaceTrim } from 'spacetrim';
-import { AGENTS_FILE_PATH } from './agentsFile';
-import {
-    getDefaultCoderProjectPromptTemplateDefinitions,
-    getDefaultCoderPromptTemplateDefinitions,
-    PROMPTS_DIRECTORY_PATH,
-    PROMPTS_DONE_DIRECTORY_PATH,
-    PROMPTS_TEMPLATES_DIRECTORY_PATH,
-} from './boilerplateTemplates';
-import { formatDisplayPath } from './formatDisplayPath';
+import { string_markdown } from '../../../types/typeAliases';
 
 /**
  * Relative path to the Promptbook Coder quick-reference file initialized in project roots.
@@ -21,127 +13,12 @@ export const AGENT_CODING_FILE_PATH = 'AGENT_CODING.md';
  *
  * @private internal utility of `ptbk coder`
  */
-export function getDefaultCoderAgentCodingFileContent({
-    packageJsonScripts,
-}: {
-    readonly packageJsonScripts: Readonly<Record<string, string>>;
-}): string {
-    return spaceTrim(
-        (block) => `
-            # Promptbook Coder quick reference
+export function getDefaultCoderAgentCodingFileContent(): string_markdown {
+    return spaceTrim(`
+        # ✨ Promptbook Coder agent coding
 
-            This project is prepared for the \`ptbk coder\` workflow. Promptbook Coder does not create a new model on its own; it orchestrates coding agents such as GitHub Copilot, OpenAI Codex, Claude Code, Opencode, Cline, and Gemini CLI through prompt files in \`${formatDisplayPath(
-                PROMPTS_DIRECTORY_PATH,
-            )}/\`.
-
-            ## Workflow
-            1. Put repository-wide coding rules into \`${AGENTS_FILE_PATH}\`. The default \`npm run coder:run\` script already passes \`--context ${AGENTS_FILE_PATH}\`.
-            2. Create or customize prompt templates in \`${formatDisplayPath(
-                PROMPTS_TEMPLATES_DIRECTORY_PATH,
-            )}/\`. ${buildStarterTemplateSentence()}
-            3. Generate prompt files with \`npm run coder:generate-boilerplates\` or \`ptbk coder generate-boilerplates --template <template> --count <count>\`. To append a single ready-to-run prompt straight from a description, use \`npm run coder:add\` or \`ptbk coder add "some new feature"\`.
-            4. Replace every \`@@@\`, keep drafts as \`[-]\`, and switch prompts to \`[ ]\` when they are ready to run. Completed prompts are marked \`[x]\`.
-            5. Run \`npm run coder:run\` to execute the next ready prompt with the configured coding agent.
-            6. Use \`npm run coder:verify\` to archive finished prompts into \`${formatDisplayPath(
-                PROMPTS_DONE_DIRECTORY_PATH,
-            )}/\` and append repair follow-up prompts when more work is needed.
-            7. Use \`ptbk coder find-refactor-candidates\` when you want Promptbook to suggest refactor prompts automatically.
-
-            ## Templates
-            -   Project-owned templates created by \`ptbk coder init\`: ${formatInlineCodeList(
-                getDefaultCoderProjectPromptTemplateDefinitions().map(({ relativeFilePath }) =>
-                    formatDisplayPath(relativeFilePath),
-                ),
-            )}
-            -   Built-in \`--template\` aliases: ${formatInlineCodeList(
-                getDefaultCoderPromptTemplateDefinitions().map(({ id }) => id),
-            )}
-            -   To add a custom template, create a markdown file such as \`${formatDisplayPath(
-                PROMPTS_TEMPLATES_DIRECTORY_PATH,
-            )}/backend.md\`.
-            -   To use a project template, run \`ptbk coder generate-boilerplates --template ${formatDisplayPath(
-                PROMPTS_TEMPLATES_DIRECTORY_PATH,
-            )}/backend.md\`.
-            -   Keep shared repository rules in \`${AGENTS_FILE_PATH}\` and recurring task-family rules in template files so individual prompt files stay focused on the actual task.
-
-            ## Created npm scripts
-            | Script | Purpose |
-            | --- | --- |
-            ${block(buildPackageJsonScriptTableLines(packageJsonScripts).join('\n'))}
-
-            ## Customizing the workflow
-            -   Edit \`package.json\` if you want \`npm run coder:run\` to use another coding agent, model, thinking level, context file, or wait mode.
-            -   Use direct CLI commands when you need one-off flags such as \`--min-priority\`, \`--max-priority\`, \`--ignore-git-changes\`, \`--no-commit\`, \`--dry-run\`, \`--test\`, \`--allow-credits\`, or \`--auto-migrate\`.
-            -   Use \`ptbk coder --help\` and \`ptbk coder <command> --help\` for the full CLI reference.
-        `,
-    );
-}
-
-/**
- * Builds the sentence describing the starter templates created during initialization.
- */
-function buildStarterTemplateSentence(): string {
-    const starterTemplatePaths = getDefaultCoderProjectPromptTemplateDefinitions().map(({ relativeFilePath }) =>
-        formatDisplayPath(relativeFilePath),
-    );
-
-    if (starterTemplatePaths.length === 1) {
-        return `The starter project template created by \`ptbk coder init\` is \`${starterTemplatePaths[0]}\`.`;
-    }
-
-    return `The starter project templates created by \`ptbk coder init\` are ${formatInlineCodeList(
-        starterTemplatePaths,
-    )}.`;
-}
-
-/**
- * Builds the markdown table rows describing the initialized npm scripts.
- */
-function buildPackageJsonScriptTableLines(packageJsonScripts: Readonly<Record<string, string>>): Array<string> {
-    return Object.entries(packageJsonScripts).map(
-        ([scriptName, scriptCommand]) =>
-            `| \`npm run ${scriptName}\` | ${describeDefaultCoderPackageJsonScript(scriptName, scriptCommand)} |`,
-    );
-}
-
-/**
- * Describes one initialized npm script in human-readable terms.
- */
-function describeDefaultCoderPackageJsonScript(scriptName: string, scriptCommand: string): string {
-    if (scriptName === 'coder:generate-boilerplates') {
-        return `Runs \`${scriptCommand}\` to create new prompt files in \`${formatDisplayPath(
-            PROMPTS_DIRECTORY_PATH,
-        )}/\`.`;
-    }
-
-    if (scriptName === 'coder:add') {
-        return `Runs \`${scriptCommand}\` to add one ready-to-run prompt file to \`${formatDisplayPath(
-            PROMPTS_DIRECTORY_PATH,
-        )}/\` from a plain-language description.`;
-    }
-
-    if (scriptName === 'coder:run') {
-        return `Runs \`${scriptCommand}\` to execute the next ready prompt with shared repository context from \`${AGENTS_FILE_PATH}\`.`;
-    }
-
-    if (scriptName === 'coder:find-refactor-candidates') {
-        return `Runs \`${scriptCommand}\` to generate prompt candidates for large or crowded files.`;
-    }
-
-    if (scriptName === 'coder:verify') {
-        return `Runs \`${scriptCommand}\` to archive verified prompts into \`${formatDisplayPath(
-            PROMPTS_DONE_DIRECTORY_PATH,
-        )}/\` and append repair prompts when needed.`;
-    }
-
-    return `Runs \`${scriptCommand}\`.`;
-}
-
-/**
- * Formats one inline code list for human-readable markdown.
- */
-function formatInlineCodeList(values: ReadonlyArray<string>): string {
-    return values.map((value) => `\`${value}\``).join(', ');
+        This project is using [Promptbook Coder](https://coder.ptbk.io) or run \`ptbk coder\`!
+    `);
 }
 
 // Note: [🟡] Code for coder AGENT_CODING file boilerplate [agentCodingFile](src/cli/cli-commands/coder/agentCodingFile.ts) should never be published outside of `@promptbook/cli`

package/src/cli/cli-commands/coder/generate-boilerplates.ts

@@ -6,6 +6,12 @@ import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { spaceTrim } from 'spacetrim';
 import type { $side_effect } from '../../../utils/organization/$side_effect';
+import type { CoderGitSyncCliOptions } from '../common/coderGitSyncCliOptions';
+import {
+    addCoderGitSyncOptions,
+    CODER_GIT_SYNC_DESCRIPTION,
+    normalizeCoderGitSyncCliOptions,
+} from '../common/coderGitSyncCliOptions';
 import { handleActionErrors } from '../common/handleActionErrors';
 import {
     buildCoderPromptSection,
@@ -24,9 +30,13 @@ import {
 export function $initializeCoderGenerateBoilerplatesCommand(program: Program): $side_effect {
     const command = program.command('generate-boilerplates');
     command.description(
-        spaceTrim(`
-            Generate prompt boilerplate files with unique emoji tags
-        `),
+        spaceTrim(
+            (block) => `
+                Generate prompt boilerplate files with unique emoji tags
+
+                ${block(CODER_GIT_SYNC_DESCRIPTION)}
+            `,
+        ),
     );
 
     command.option('--count <count>', `Number of prompt boilerplate files to generate`, '5');
@@ -40,22 +50,38 @@ export function $initializeCoderGenerateBoilerplatesCommand(program: Program): $
                 .join(', ')}) or a markdown file path relative to the current project root.
         `),
     );
+    addCoderGitSyncOptions(command);
 
     command.action(
         handleActionErrors(async (cliOptions) => {
             const { count: countOption, template: templateOption } = cliOptions as {
                 readonly count: string;
                 readonly template?: string;
-            };
+            } & CoderGitSyncCliOptions;
 
             const filesCount = parseFilesCount(countOption);
+            const gitSync = normalizeCoderGitSyncCliOptions(cliOptions as CoderGitSyncCliOptions);
+            const projectPath = process.cwd();
+
+            // Note: Import the git synchronization dynamically to keep the CLI fast for runs without `--commit`
+            const { $commitCoderChanges, $pullCoderChanges } = await import(
+                '../../../../scripts/run-codex-prompts/git/coderGitSync'
+            );
+
+            await $pullCoderChanges({ gitSync, projectPath });
 
             await generatePromptBoilerplate({
-                projectPath: process.cwd(),
+                projectPath,
                 filesCount,
                 templateOption,
             });
 
+            await $commitCoderChanges({
+                gitSync,
+                projectPath,
+                commitMessage: `Prompts ${filesCount}x`,
+            });
+
             return process.exit(0);
         }),
     );

package/src/cli/cli-commands/coder/getDefaultCoderPackageJsonScripts.ts

@@ -5,7 +5,7 @@ const DEFAULT_CODER_PACKAGE_JSON_SCRIPTS = {
     'coder:generate-boilerplates': 'ptbk coder generate-boilerplates --template ./prompts/templates/common.md',
     'coder:add': 'ptbk coder add --template ./prompts/templates/common.md',
     'coder:run':
-        'ptbk coder run --harness openai-codex --model gpt-5.5 --thinking-level xhigh --agent agents/developer.book --context AGENTS.md',
+        'ptbk coder run --harness openai-codex --model gpt-5.6-terra --thinking-level max --agent agents/developer.book --context AGENTS.md --test-before yes-and-fix',
     // 'coder:find-refactor-candidates': 'npx ptbk coder find-refactor-candidates',
     'coder:verify': 'ptbk coder verify',
 } as const satisfies Readonly<Record<string, string>>;