@promptbook/cli 0.114.0-1 → 0.114.0-3

package/umd/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('commander'), require('spacetrim'), require('fs/promises'), require('path'), require('crypto'), require('child_process'), require('moment'), require('fs'), require('dotenv'), require('prompts'), require('readline'), require('waitasecond'), require('crypto-js/enc-hex'), require('crypto-js/sha256'), require('socket.io-client'), require('jszip'), require('@mozilla/readability'), require('jsdom'), require('crypto-js'), require('showdown'), require('glob-promise'), require('http'), require('express'), require('socket.io'), require('express-openapi-validator'), require('swagger-ui-express'), require('react'), require('react-dom/server'), require('@anthropic-ai/sdk'), require('bottleneck'), require('@azure/openai'), require('rxjs'), require('@openai/agents'), require('openai'), require('typescript'), require('ignore'), require('events'), require('os'), require('mime-types'), require('papaparse'), require('pg'), require('@supabase/supabase-js'), require('url')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'commander', 'spacetrim', 'fs/promises', 'path', 'crypto', 'child_process', 'moment', 'fs', 'dotenv', 'prompts', 'readline', 'waitasecond', 'crypto-js/enc-hex', 'crypto-js/sha256', 'socket.io-client', 'jszip', '@mozilla/readability', 'jsdom', 'crypto-js', 'showdown', 'glob-promise', 'http', 'express', 'socket.io', 'express-openapi-validator', 'swagger-ui-express', 'react', 'react-dom/server', '@anthropic-ai/sdk', 'bottleneck', '@azure/openai', 'rxjs', '@openai/agents', 'openai', 'typescript', 'ignore', 'events', 'os', 'mime-types', 'papaparse', 'pg', '@supabase/supabase-js', 'url'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-cli"] = {}, global.colors, global.commander, global._spaceTrim, global.promises, global.path, global.crypto, global.child_process, global.moment, global.fs, global.dotenv, global.prompts, global.readline, global.waitasecond, global.hexEncoder, global.sha256, global.socket_ioClient, global.JSZip, global.readability, global.jsdom, global.CryptoJS, global.showdown, global.glob, global.http, global.express, global.socket_io, global.OpenApiValidator, global.swaggerUi, global.react, global.server, global.Anthropic, global.Bottleneck, global.openai, global.rxjs, global.agents, global.OpenAI, global.ts, global.ignore, global.events, global.os, global.mimeTypes, global.papaparse, global.pg, null, global.url));
-})(this, (function (exports, colors, commander, _spaceTrim, promises, path, crypto, child_process, moment, fs, dotenv, prompts, readline, waitasecond, hexEncoder, sha256, socket_ioClient, JSZip, readability, jsdom, CryptoJS, showdown, glob, http, express, socket_io, OpenApiValidator, swaggerUi, react, server, Anthropic, Bottleneck, openai, rxjs, agents, OpenAI, ts, ignore, events, os, mimeTypes, papaparse, pg, supabaseJs, url) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('commander'), require('spacetrim'), require('fs/promises'), require('path'), require('crypto'), require('child_process'), require('moment'), require('fs'), require('dotenv'), require('readline'), require('waitasecond'), require('crypto-js/enc-hex'), require('crypto-js/sha256'), require('crypto-js'), require('showdown'), require('glob-promise'), require('http'), require('express'), require('socket.io'), require('express-openapi-validator'), require('swagger-ui-express'), require('react'), require('react-dom/server'), require('bottleneck'), require('rxjs'), require('ignore'), require('events'), require('os'), require('mime-types'), require('papaparse'), require('@supabase/supabase-js'), require('url')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'commander', 'spacetrim', 'fs/promises', 'path', 'crypto', 'child_process', 'moment', 'fs', 'dotenv', 'readline', 'waitasecond', 'crypto-js/enc-hex', 'crypto-js/sha256', 'crypto-js', 'showdown', 'glob-promise', 'http', 'express', 'socket.io', 'express-openapi-validator', 'swagger-ui-express', 'react', 'react-dom/server', 'bottleneck', 'rxjs', 'ignore', 'events', 'os', 'mime-types', 'papaparse', '@supabase/supabase-js', 'url'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-cli"] = {}, global.colors, global.commander, global._spaceTrim, global.promises, global.path, global.crypto, global.child_process, global.moment, global.fs, global.dotenv, global.readline, global.waitasecond, global.hexEncoder, global.sha256, global.CryptoJS, global.showdown, global.glob, global.http, global.express, global.socket_io, global.OpenApiValidator, global.swaggerUi, global.react, global.server, global.Bottleneck, global.rxjs, global.ignore, global.events, global.os, global.mimeTypes, global.papaparse, null, global.url));
+})(this, (function (exports, colors, commander, _spaceTrim, promises, path, crypto, child_process, moment, fs, dotenv, readline, waitasecond, hexEncoder, sha256, CryptoJS, showdown, glob, http, express, socket_io, OpenApiValidator, swaggerUi, react, server, Bottleneck, rxjs, ignore, events, os, mimeTypes, papaparse, supabaseJs, url) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -30,11 +30,9 @@
     var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
     var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
     var dotenv__namespace = /*#__PURE__*/_interopNamespace(dotenv);
-    var prompts__default = /*#__PURE__*/_interopDefaultLegacy(prompts);
     var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
     var hexEncoder__default = /*#__PURE__*/_interopDefaultLegacy(hexEncoder);
     var sha256__default = /*#__PURE__*/_interopDefaultLegacy(sha256);
-    var JSZip__default = /*#__PURE__*/_interopDefaultLegacy(JSZip);
     var CryptoJS__default = /*#__PURE__*/_interopDefaultLegacy(CryptoJS);
     var showdown__default = /*#__PURE__*/_interopDefaultLegacy(showdown);
     var glob__default = /*#__PURE__*/_interopDefaultLegacy(glob);
@@ -42,10 +40,7 @@
     var express__default = /*#__PURE__*/_interopDefaultLegacy(express);
     var OpenApiValidator__namespace = /*#__PURE__*/_interopNamespace(OpenApiValidator);
     var swaggerUi__default = /*#__PURE__*/_interopDefaultLegacy(swaggerUi);
-    var Anthropic__default = /*#__PURE__*/_interopDefaultLegacy(Anthropic);
     var Bottleneck__default = /*#__PURE__*/_interopDefaultLegacy(Bottleneck);
-    var OpenAI__default = /*#__PURE__*/_interopDefaultLegacy(OpenAI);
-    var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
     var ignore__default = /*#__PURE__*/_interopDefaultLegacy(ignore);
     var papaparse__default = /*#__PURE__*/_interopDefaultLegacy(papaparse);
 
@@ -63,7 +58,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-1';
+    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-3';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3297,6 +3292,12 @@
      * @private internal constant of `buildAgentsServer`
      */
     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`
+     */
+    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.
      *
@@ -3321,6 +3322,11 @@
                     [PTBK_AGENTS_SERVER_IGNORE_NEXT_VALIDATION_ENV]: 'true',
                 }
                 : {}),
+            ...(options.isWebpackFilesystemCacheDisabled
+                ? {
+                    [PTBK_AGENTS_SERVER_DISABLE_WEBPACK_FILESYSTEM_CACHE_ENV]: 'true',
+                }
+                : {}),
         };
     }
     /**
@@ -4054,6 +4060,7 @@
         });
         const buildEnvironment = createAgentsServerRuntimeEnvironment(environment, preparedRuntime.nodeModulesPath, {
             isNextValidationIgnored: preparedRuntime.isAppPathMaterialized,
+            isWebpackFilesystemCacheDisabled: true,
         });
         if (!options.isBuildForced &&
             (await isAgentsServerBuildCacheCurrent({
@@ -26970,12 +26977,12 @@
      * Builds the coder-run control pills shown in the footer box.
      */
     function buildCoderRunControlPills(options) {
-        const { pauseControl, pendingEnterLabel, isEndAfterCurrentPromptRequested, sessionTotal } = options;
+        const { phase, pauseControl, pendingEnterLabel, isEndAfterCurrentPromptRequested, sessionTotal } = options;
         return buildControlPills({
             pauseControl,
             pendingEnterLabel,
             additionalControls: [
-                buildSkipCurrentWaitControl(),
+                ...(phase === 'waiting' ? [buildSkipCurrentWaitControl()] : []),
                 buildEndAfterCurrentPromptControl(isEndAfterCurrentPromptRequested, sessionTotal),
             ],
         });
@@ -28230,6 +28237,13 @@
      * Environment variable read by the shell wrapper to tee live output into the temporary runtime log file.
      */
     const PTBK_CODER_LOG_FILE_ENV_NAME = 'PTBK_CODER_LOG_FILE';
+    /**
+     * Log line which separates the raw script input from the raw script output of one execution section.
+     *
+     * Readers of a runtime log split on this marker to look only at what the harness really produced,
+     * without the generated script and the prompt it embeds.
+     */
+    const SCRIPT_EXECUTION_LOG_RAW_OUTPUT_MARKER = '--- raw output ---';
     /**
      * Small bash wrapper that preserves stdout/stderr streams while teeing both into the runtime log file.
      */
@@ -28265,7 +28279,7 @@
             --- raw input ---
             ${block(normalizedInput)}
 
-            --- raw output ---
+            ${SCRIPT_EXECUTION_LOG_RAW_OUTPUT_MARKER}
         `);
         await promises.appendFile(logPath, `${logSection}\n`, 'utf-8');
     }
@@ -29556,6 +29570,7 @@
             `    -c model_reasoning_effort="${thinkingLevel}" \\`,
             `    --ask-for-approval ${options.askForApproval} \\`,
             `    exec --model ${options.model} \\`,
+            ...(options.isMachineReadableProgressEnabled ? ['    --json \\'] : []),
             '    --local-provider none \\',
             `    --sandbox ${options.sandbox} \\`,
             `    -C ${projectPath} \\`,
@@ -29872,6 +29887,10 @@
      * Output line that marks finished Codex usage summary.
      */
     const CODEX_COMPLETION_LINE = /^\s*tokens used\b/i;
+    /**
+     * Output line that marks the completed Codex turn in JSONL output mode.
+     */
+    const CODEX_JSON_COMPLETION_LINE = /^\s*\{"type":"turn\.(?:completed|failed)"/u;
     /**
      * Idle timeout after completion marker to capture trailing output.
      */
@@ -29948,6 +29967,7 @@
                 sandbox: this.options.sandbox,
                 askForApproval: this.options.askForApproval,
                 allowCredits: this.options.allowCredits,
+                isMachineReadableProgressEnabled: this.options.isMachineReadableProgressEnabled,
                 codexCommand: this.options.codexCommand,
             });
             for (let retryIndex = 0;; retryIndex++) {
@@ -29962,7 +29982,9 @@
                     const output = await $runGoScriptUntilMarkerIdle({
                         scriptPath: options.scriptPath,
                         scriptContent,
-                        completionLineMatcher: CODEX_COMPLETION_LINE,
+                        completionLineMatcher: this.options.isMachineReadableProgressEnabled
+                            ? CODEX_JSON_COMPLETION_LINE
+                            : CODEX_COMPLETION_LINE,
                         idleTimeoutMs: CODEX_COMPLETION_IDLE_MS,
                         logPath: options.logPath,
                         shouldPrintLiveOutput: options.shouldPrintLiveOutput,
@@ -30212,6 +30234,7 @@
             sandbox: 'danger-full-access',
             askForApproval: 'never',
             allowCredits: options.allowCredits,
+            isMachineReadableProgressEnabled: options.isMachineReadableProgressEnabled,
         });
         if (!options.allowCredits && options.isVerbose === true) {
             console.info(colors__default["default"].gray('OpenAI Codex credit spending is disabled. Use `--allow-credits` to explicitly opt in.'));
@@ -31447,6 +31470,7 @@
             : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
         const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
         const controls = buildCoderRunControlPills({
+            phase: options.phase,
             pauseControl: pausePresentation.pauseControl,
             pendingEnterLabel: options.pendingEnterLabel,
             isEndAfterCurrentPromptRequested: options.isEndAfterCurrentPromptRequested,
@@ -32310,6 +32334,7 @@
             autoPull: options.autoPull,
             agentName: options.agentName,
             model: options.model,
+            isMachineReadableProgressEnabled: options.isMachineReadableProgressEnabled,
             priority: 0,
         };
     }
@@ -32931,8 +32956,12 @@
      * `options.includePaths` can restrict staging, `options.onlyPaths` can restrict the commit pathspec,
      * `options.excludePaths` can keep temporary artifacts out of the created commit and
      * `options.isEmptyCommitAllowed` keeps a round without any file change from failing.
+     *
+     * Note: The temporary commit message file is written inside the project, so it is always excluded from the commit
+     *       itself for projects which do not keep the Promptbook temporary directory out of version control.
      */
     async function commitChanges(message, options) {
+        var _a;
         const projectPath = (options === null || options === void 0 ? void 0 : options.projectPath) || process.cwd();
         const commitMessagePath = resolvePromptbookTemporaryPath(projectPath, 'ptbk-coder', 'commit-messages', `COMMIT_MESSAGE_${Date.now()}.txt`);
         await promises.mkdir(path.dirname(commitMessagePath), { recursive: true });
@@ -32940,7 +32969,10 @@
         try {
             const agentEnv = buildAgentGitEnv();
             const signingFlag = buildAgentGitSigningFlag();
-            await stageCommitChanges(projectPath, agentEnv, options === null || options === void 0 ? void 0 : options.includePaths, options === null || options === void 0 ? void 0 : options.excludePaths);
+            await stageCommitChanges(projectPath, agentEnv, options === null || options === void 0 ? void 0 : options.includePaths, [
+                commitMessagePath,
+                ...((_a = options === null || options === void 0 ? void 0 : options.excludePaths) !== null && _a !== void 0 ? _a : []),
+            ]);
             await runGitCommand({
                 command: buildGitCommitCommand({
                     commitMessagePath,
@@ -33299,6 +33331,21 @@
         `);
     }
 
+    /**
+     * Maximum amount of test output embedded into an agent prompt.
+     */
+    const MAX_TEST_OUTPUT_CHARS = 12000;
+    /**
+     * Limits test output while keeping the end of the output, where test runners usually print the failure summary.
+     */
+    function limitTestOutput(testOutput) {
+        const normalizedTestOutput = testOutput.trim();
+        if (normalizedTestOutput.length <= MAX_TEST_OUTPUT_CHARS) {
+            return normalizedTestOutput;
+        }
+        return `[..., test output truncated to the last ${MAX_TEST_OUTPUT_CHARS} characters...]\n${normalizedTestOutput.slice(-MAX_TEST_OUTPUT_CHARS)}`;
+    }
+
     /**
      * Runs the configured verification command inside the project root and returns its output.
      */
@@ -33319,10 +33366,6 @@
      * Maximum number of coding attempts allowed for the same prompt when verification keeps failing.
      */
     const MAX_PROMPT_TEST_ATTEMPTS = 3;
-    /**
-     * Maximum amount of verification output sent back to the coding agent as retry feedback.
-     */
-    const MAX_TEST_FEEDBACK_OUTPUT_CHARS = 12000;
     /**
      * File extension used by generated shell scripts.
      */
@@ -33368,7 +33411,7 @@
                 return { ...result, attemptCount, steps };
             }
             const fullVerificationOutput = formatUnknownErrorDetails(failedVerification.error);
-            const feedbackVerificationOutput = limitVerificationOutputForFeedback(fullVerificationOutput);
+            const feedbackVerificationOutput = limitTestOutput(fullVerificationOutput);
             if (attemptCount >= MAX_PROMPT_TEST_ATTEMPTS) {
                 console.error(colors__default["default"].red(`Verification failed for ${options.promptLabel} after ${attemptCount} attempts.`));
                 throw new Error(buildFinalVerificationFailureMessage({
@@ -33498,19 +33541,6 @@
             \`\`\`
         `);
     }
-    /**
-     * Limits verification output before it is embedded back into the next coding prompt.
-     */
-    function limitVerificationOutputForFeedback(verificationOutput) {
-        const normalizedVerificationOutput = verificationOutput.trim();
-        if (normalizedVerificationOutput.length <= MAX_TEST_FEEDBACK_OUTPUT_CHARS) {
-            return normalizedVerificationOutput;
-        }
-        return spaceTrim(`
-        [...verification output truncated to the last ${MAX_TEST_FEEDBACK_OUTPUT_CHARS} characters...]
-        ${normalizedVerificationOutput.slice(-MAX_TEST_FEEDBACK_OUTPUT_CHARS)}
-    `);
-    }
     /**
      * Derives a dedicated temp-script path for verification commands.
      */
@@ -41371,6 +41401,7 @@
             autoClone: false,
             maxMessageProcessingFailures: localAgentRunnerLimits.maxFailedAttempts,
             maxParallelMessages: localAgentRunnerLimits.maxParallelMessages,
+            isMachineReadableProgressEnabled: true,
         };
     }
 
@@ -42281,6 +42312,91 @@
     // Note: [🟡] Code for CLI command [agents-server](src/cli/cli-commands/agents-server.ts) should never be published outside of `@promptbook/cli`
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * Creates a loader which imports one module on the first call and reuses the very same module afterwards
+     *
+     * Note: [🐌] Heavy third-party dependencies are imported lazily to keep the startup of the Promptbook CLI fast.
+     *       A statically imported dependency is loaded every single time the bundle is loaded, even when the running
+     *       command never touches it. A lazily imported dependency is loaded only when the feature is really used.
+     *
+     * @example
+     * const loadJsdomModule = createLazyModuleLoader(() => import('jsdom'));
+     * const { JSDOM } = await loadJsdomModule();
+     *
+     * @private internal utility of Promptbook
+     */
+    function createLazyModuleLoader(importModule) {
+        let importedModulePromise = null;
+        return function loadModule() {
+            if (importedModulePromise === null) {
+                importedModulePromise = importModule();
+            }
+            return importedModulePromise;
+        };
+    }
+    // Note: [🐌] Do not convert the lazy `import(...)` calls back to static `import` statements, it would bring back the
+    //       slow startup of the `ptbk` CLI utility
+
+    /**
+     * Loads the interactive terminal prompt library (`prompts`) on demand
+     *
+     * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast - most commands never ask the user
+     *       anything interactively
+     *
+     * @private internal utility of Promptbook CLI
+     */
+    const loadPromptsModule = createLazyModuleLoader(() => import('prompts'));
+    // Note: [🟡] Code for CLI prompt loading [loadPromptsModule](src/cli/common/loadPromptsModule.ts) should never be published outside of `@promptbook/cli`
+
+    /**
+     * Description block shared by the `ptbk coder` commands which can synchronize their changes with git.
+     *
+     * @private internal utility of `promptbookCli`
+     */
+    const CODER_GIT_SYNC_DESCRIPTION = _spaceTrim.spaceTrim(`
+    Git synchronization:
+    - --auto-pull pulls the latest changes before this command changes anything
+    - --commit commits the changes made by this command
+    - --auto-push pushes the created commit to the remote repository
+`);
+    /**
+     * Registers the shared `--commit`, `--auto-push` and `--auto-pull` flags on a `ptbk coder` command.
+     *
+     * Note: Unlike `ptbk coder run`, which commits by default and opts out through `--no-commit`,
+     *       these commands never touch git unless the flags are used explicitly.
+     *
+     * @private internal utility of `promptbookCli`
+     */
+    function addCoderGitSyncOptions(command) {
+        command.option('--commit', 'Commit the changes made by this command with the coding-agent git identity', false);
+        command.option('--auto-push', 'Automatically git push the created commit, requires --commit', false);
+        command.option('--auto-pull', 'Automatically git pull the latest changes before this command changes anything', false);
+    }
+    /**
+     * Converts the Commander git synchronization flags into normalized git synchronization options.
+     *
+     * @private internal utility of `promptbookCli`
+     */
+    function normalizeCoderGitSyncCliOptions(cliOptions) {
+        if (cliOptions.autoPush && !cliOptions.commit) {
+            throw new NotAllowed(_spaceTrim.spaceTrim(`
+                Flag \`--auto-push\` can be used only together with \`--commit\`.
+
+                **There is nothing to push when the changes are not committed.**
+
+                Actionable hint:
+                - Add \`--commit\`, for example \`ptbk coder init --commit --auto-push\`.
+            `));
+        }
+        return {
+            isCommitEnabled: cliOptions.commit,
+            isAutoPushEnabled: cliOptions.autoPush,
+            isAutoPullEnabled: cliOptions.autoPull,
+        };
+    }
+    // Note: [🟡] Code for CLI git synchronization options [coderGitSyncCliOptions](src/cli/cli-commands/common/coderGitSyncCliOptions.ts) should never be published outside of `@promptbook/cli`
+    // Note: [💞] Ignore a discrepancy between file name and exported helper names
+
     /**
      * Relative path to the root prompts directory used by Promptbook coder utilities.
      *
@@ -42534,15 +42650,17 @@
      */
     function $initializeCoderAddCommand(program) {
         const command = program.command('add');
-        command.description(_spaceTrim.spaceTrim(`
-            Add one ready-to-run prompt file to the queue
+        command.description(_spaceTrim.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');
         command.option('--priority <priority>', 'Priority of the new prompt — higher priorities run first (rendered as trailing `!` markers)', parsePriorityOption, 0);
         command.option('--template <template>', _spaceTrim.spaceTrim(`
@@ -42552,15 +42670,26 @@
         .map(({ id }) => id)
         .join(', ')}) or a markdown file path relative to the current project root.
         `));
+        addCoderGitSyncOptions(command);
         command.action(handleActionErrors(async (descriptionArgument, cliOptions) => {
             const { priority, template: templateOption } = cliOptions;
+            const gitSync = normalizeCoderGitSyncCliOptions(cliOptions);
+            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 Promise.resolve().then(function () { return coderGitSync; });
+            await $pullCoderChanges({ gitSync, projectPath });
+            const { /* filePath,*/ emojiTag } = await addCoderPrompt({
+                projectPath,
                 description,
                 priority,
                 templateOption,
             });
+            await $commitCoderChanges({
+                gitSync,
+                projectPath,
+                commitMessage: `${emojiTag} Add prompt`,
+            });
         }));
     }
     /**
@@ -42634,7 +42763,8 @@
             }
             return standardInputDescription;
         }
-        const response = await prompts__default["default"]({
+        const { default: prompts } = await loadPromptsModule();
+        const response = await prompts({
             type: 'text',
             name: 'description',
             message: 'Describe the feature or task to add',
@@ -43054,9 +43184,11 @@
      */
     function $initializeCoderGenerateBoilerplatesCommand(program) {
         const command = program.command('generate-boilerplates');
-        command.description(_spaceTrim.spaceTrim(`
-            Generate prompt boilerplate files with unique emoji tags
-        `));
+        command.description(_spaceTrim.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');
         command.option('--template <template>', _spaceTrim.spaceTrim(`
             Prompt template to use.
@@ -43065,14 +43197,25 @@
         .map(({ id }) => id)
         .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;
             const filesCount = parseFilesCount(countOption);
+            const gitSync = normalizeCoderGitSyncCliOptions(cliOptions);
+            const projectPath = process.cwd();
+            // Note: Import the git synchronization dynamically to keep the CLI fast for runs without `--commit`
+            const { $commitCoderChanges, $pullCoderChanges } = await Promise.resolve().then(function () { return 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);
         }));
     }
@@ -43485,6 +43628,27 @@
     }
     // Note: [🟡] Code for CLI harness installation orchestration [$ensureHarnessInstallations](src/cli/cli-commands/common/harness/$ensureHarnessInstallations.ts) should never be published outside of `@promptbook/cli`
 
+    /**
+     * Relative path to the Promptbook Coder quick-reference file initialized in project roots.
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    const AGENT_CODING_FILE_PATH = 'AGENT_CODING.md';
+    /**
+     * Returns the default coder `AGENT_CODING.md` quick-reference content.
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    function getDefaultCoderAgentCodingFileContent() {
+        return _spaceTrim.spaceTrim(`
+        # ✨ Promptbook Coder agent coding
+
+        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`
+    // Note: [💞] Ignore a discrepancy between file name and exported helper names
+
     /**
      * Relative path to the shared coder context file initialized in project roots.
      *
@@ -43512,106 +43676,6 @@
     // Note: [🟡] Code for coder AGENTS file boilerplate [agentsFile](src/cli/cli-commands/coder/agentsFile.ts) should never be published outside of `@promptbook/cli`
     // Note: [💞] Ignore a discrepancy between file name and exported helper names
 
-    /**
-     * Normalizes one project-relative path for human-readable CLI output and markdown.
-     *
-     * @private internal utility of `ptbk coder`
-     */
-    function formatDisplayPath(relativePath) {
-        return relativePath.replace(/\\/gu, '/');
-    }
-    // Note: [🟡] Code for coder path formatting [formatDisplayPath](src/cli/cli-commands/coder/formatDisplayPath.ts) should never be published outside of `@promptbook/cli`
-
-    /**
-     * Relative path to the Promptbook Coder quick-reference file initialized in project roots.
-     *
-     * @private internal utility of `ptbk coder`
-     */
-    const AGENT_CODING_FILE_PATH = 'AGENT_CODING.md';
-    /**
-     * Returns the default coder `AGENT_CODING.md` quick-reference content.
-     *
-     * @private internal utility of `ptbk coder`
-     */
-    function getDefaultCoderAgentCodingFileContent({ packageJsonScripts, }) {
-        return _spaceTrim.spaceTrim((block) => `
-            # Promptbook Coder quick reference
-
-            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() {
-        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) {
-        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, scriptCommand) {
-        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) {
-        return values.map((value) => `\`${value}\``).join(', ');
-    }
-    // Note: [🟡] Code for coder AGENT_CODING file boilerplate [agentCodingFile](src/cli/cli-commands/coder/agentCodingFile.ts) should never be published outside of `@promptbook/cli`
-    // Note: [💞] Ignore a discrepancy between file name and exported helper names
-
     /**
      * Relative directory path for agents initialized by `ptbk coder init`.
      *
@@ -43676,6 +43740,16 @@
     }
     // Note: [🟡] Code for coder init developer agent bootstrapping [ensureCoderDeveloperAgentFile](src/cli/cli-commands/coder/ensureCoderDeveloperAgentFile.ts) should never be published outside of `@promptbook/cli`
 
+    /**
+     * Normalizes one project-relative path for human-readable CLI output and markdown.
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    function formatDisplayPath(relativePath) {
+        return relativePath.replace(/\\/gu, '/');
+    }
+    // Note: [🟡] Code for coder path formatting [formatDisplayPath](src/cli/cli-commands/coder/formatDisplayPath.ts) should never be published outside of `@promptbook/cli`
+
     /**
      * Fallback `.env` content used when no required variables need to be appended.
      */
@@ -43753,7 +43827,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',
+        'coder:run': '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',
     };
@@ -44002,9 +44076,7 @@
         const agentsDirectoryStatus = await ensureDirectory(projectPath, CODER_AGENTS_DIRECTORY_PATH);
         const developerAgentFileStatus = await ensureCoderDeveloperAgentFile(projectPath);
         const agentsFileStatus = await ensureCoderMarkdownFile(projectPath, AGENTS_FILE_PATH, getDefaultCoderAgentsFileContent());
-        const agentCodingFileStatus = await ensureCoderMarkdownFile(projectPath, AGENT_CODING_FILE_PATH, getDefaultCoderAgentCodingFileContent({
-            packageJsonScripts: getDefaultCoderPackageJsonScripts(),
-        }));
+        const agentCodingFileStatus = await ensureCoderMarkdownFile(projectPath, AGENT_CODING_FILE_PATH, getDefaultCoderAgentCodingFileContent());
         const { envFileStatus, initializedEnvVariableNames } = await ensureCoderEnvFile(projectPath);
         const gitignoreFileStatus = await ensureCoderGitignoreFile(projectPath);
         const packageJsonFileStatus = await ensureCoderPackageJsonFile(projectPath);
@@ -44119,12 +44191,24 @@
 
                 Checks that the coding harnesses are installed globally and up to date:
                 ${block(listCheckedHarnessLabels())}
+
+                ${block(CODER_GIT_SYNC_DESCRIPTION)}
             `));
-        command.action(handleActionErrors(async () => {
+        addCoderGitSyncOptions(command);
+        command.action(handleActionErrors(async (cliOptions) => {
+            const gitSync = normalizeCoderGitSyncCliOptions(cliOptions);
             const projectPath = process.cwd();
+            // Note: Import the git synchronization dynamically to keep the CLI fast for runs without `--commit`
+            const { $commitCoderChanges, $pullCoderChanges } = await Promise.resolve().then(function () { return coderGitSync; });
+            await $pullCoderChanges({ gitSync, projectPath });
             const summary = await initializeCoderProjectConfiguration(projectPath);
             printInitializationSummary(summary);
             await generatePromptBoilerplate({ projectPath, filesCount: 5 });
+            await $commitCoderChanges({
+                gitSync,
+                projectPath,
+                commitMessage: 'Initialize Promptbook Coder',
+            });
             await $ensureHarnessInstallations(CODER_INIT_CHECKED_HARNESS_NAMES);
         }));
     }
@@ -44145,6 +44229,48 @@
     // Note: [🟡] Code for CLI command [init](src/cli/cli-commands/coder/init.ts) should never be published outside of `@promptbook/cli`
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * Initializes `coder ping` command for Promptbook CLI utilities
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it registers a command in the CLI
+     *
+     * @private internal function of `promptbookCli`
+     */
+    function $initializeCoderPingCommand(program) {
+        const command = program.command('ping');
+        command.description(_spaceTrim.spaceTrim(`
+            Send one tiny dummy prompt to a harness and model to measure and warm them up
+
+            ${PROMPT_RUNNER_DESCRIPTION}
+
+            Features:
+            - Verifies that the selected harness, model, thinking level and authentication really work
+            - Reports the answer of the harness, the response time and the reported usage
+            - Starts the hourly/weekly quota window before you need it, so it is already refreshing when you do
+            - Leaves the project exactly as it was — nothing is read, written, changed or committed
+            - Use --no-ui to stream the raw harness output instead of only the compact result
+        `));
+        addPromptRunnerSelectionOptions(command);
+        addPromptRunnerRuntimeOptions(command);
+        command.action(handleActionErrors(async (cliOptions) => {
+            const runnerOptions = normalizePromptRunnerSelectionCliOptions(cliOptions, { isAgentRequired: true });
+            await $ensureHarnessInstallations([runnerOptions.agentName]);
+            // Note: Import the ping dynamically to avoid loading heavy dependencies until needed
+            const { pingCoderHarness } = await Promise.resolve().then(function () { return pingCoderHarness$1; });
+            const { printCoderPingResult } = await Promise.resolve().then(function () { return printCoderPingResult$1; });
+            const result = await pingCoderHarness({
+                agentName: runnerOptions.agentName,
+                model: runnerOptions.model,
+                thinkingLevel: runnerOptions.thinkingLevel,
+                allowCredits: runnerOptions.allowCredits,
+                shouldPrintLiveOutput: runnerOptions.noUi,
+            });
+            printCoderPingResult(result);
+        }));
+    }
+    // Note: [🟡] Code for CLI command [ping](src/cli/cli-commands/coder/ping.ts) should never be published outside of `@promptbook/cli`
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
     /**
      * Creates a Commander argument parser that accepts only non-negative integers.
      *
@@ -44169,6 +44295,21 @@
     }
     // Note: [🟡] Code for CLI option parser [createNonNegativeIntegerOptionParser](src/cli/cli-commands/common/createNonNegativeIntegerOptionParser.ts) should never be published outside of `@promptbook/cli`
 
+    /**
+     * Modes supported by `ptbk coder run --test-before`.
+     */
+    const TEST_BEFORE_MODE_VALUES = ['no', 'yes-and-fail', 'yes-and-fix'];
+    /**
+     * Default verification command used when a pre-coding mode is enabled without an explicit `--test` command.
+     */
+    const DEFAULT_CODER_TEST_COMMAND = 'npm test';
+    /**
+     * Checks whether a value is a supported `--test-before` mode.
+     */
+    function isTestBeforeMode(value) {
+        return TEST_BEFORE_MODE_VALUES.includes(value);
+    }
+
     /**
      * Default wait duration applied before retrying a prompt round after an error (10 minutes).
      *
@@ -44213,6 +44354,7 @@
             - Optional --no-ui keeps plain streaming console output for logging and debugging
             - Checks that the selected harness is installed globally and up to date before the first prompt
             - Supports GPG signing of commits
+            - Optional pre-coding test run that can stop or repair pre-existing failures
             - Optional post-prompt verification with test-feedback retries
             - Progress tracking and interactive P/S/X terminal controls
             - Dry-run mode to preview prompts
@@ -44222,6 +44364,9 @@
         command.option('--agent <agent-book-path>', 'Path to a .book file whose compiled system message is prepended to each coding prompt');
         command.option('--context <context-or-file>', 'Append extra instructions either inline or from a file path relative to the current project');
         command.option('--test <test-command...>', 'Run a verification command after each prompt; quote it when the command itself contains top-level flags');
+        command.addOption(new commander.Option('--test-before <mode>', `Run tests before coding: ${TEST_BEFORE_MODE_VALUES.join(', ')} (defaults to no; uses npm test when --test is omitted)`)
+            .choices([...TEST_BEFORE_MODE_VALUES])
+            .default('no'));
         command.option('--preserve-logs', 'Keep generated temp prompt/log artifacts after successful rounds for debugging and analytics', false);
         addPromptRunnerExecutionOptions(command);
         command.option('--isolate', _spaceTrim.spaceTrim(`
@@ -44251,8 +44396,9 @@
         command.option('--auto-migrate', 'Run testing-server database migrations automatically after each successfully processed prompt');
         command.option('--allow-destructive-auto-migrate', 'Allow auto-migrate even when heuristic SQL safety check flags destructive pending migrations');
         command.action(handleActionErrors(async (cliOptions) => {
-            const { dryRun, agent, context, test, preserveLogs, isolate: isIsolated, priority, minPriority: minimumPriority, maxPriority: maximumPriority, limit, waitAfterPrompt: waitAfterPromptValue, waitBetweenPrompts: waitBetweenPromptsValue, waitAfterError: waitAfterErrorValue, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
-            const testCommand = normalizeCommandOptionValue$1(test);
+            const { dryRun, agent, context, test, testBefore, preserveLogs, isolate: isIsolated, priority, minPriority: minimumPriority, maxPriority: maximumPriority, limit, waitAfterPrompt: waitAfterPromptValue, waitBetweenPrompts: waitBetweenPromptsValue, waitAfterError: waitAfterErrorValue, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
+            const configuredTestCommand = normalizeCommandOptionValue$1(test);
+            const testCommand = configuredTestCommand !== null && configuredTestCommand !== void 0 ? configuredTestCommand : (testBefore === 'no' ? undefined : DEFAULT_CODER_TEST_COMMAND);
             const runnerOptions = normalizePromptRunnerCliOptions(cliOptions, {
                 isAgentRequired: !dryRun,
             });
@@ -44281,6 +44427,7 @@
                 agent,
                 context,
                 testCommand,
+                testBefore,
                 preserveLogs,
                 isIsolated,
                 noUi: runnerOptions.noUi,
@@ -44491,25 +44638,31 @@
      */
     function $initializeCoderVerifyCommand(program) {
         const command = program.command('verify');
-        command.description(_spaceTrim.spaceTrim(`
-            Interactive verification helper for completed prompts
+        command.description(_spaceTrim.spaceTrim((block) => `
+                Interactive verification helper for completed prompts
 
-            Features:
-            - Displays list of prompt files with status counts
-            - Guides through verification of completed prompts marked [x]
-            - Archives verified prompt files to prompts/done/ directory
-            - Auto-appends repair prompts for incomplete work
-            - Processes files with all-done prompts first
-            - Supports ignoring matching prompt candidates for one verification run
-        `));
+                Features:
+                - Displays list of prompt files with status counts
+                - Guides through verification of completed prompts marked [x]
+                - Archives verified prompt files to prompts/done/ directory
+                - Auto-appends repair prompts for incomplete work
+                - Processes files with all-done prompts first
+                - Supports ignoring matching prompt candidates for one verification run
+
+                ${block(CODER_GIT_SYNC_DESCRIPTION)}
+
+                Note: The git synchronization is applied around each single verification, not once per run.
+            `));
         command.option('--reverse', 'Process prompt files in reverse order', false);
         command.option('--ignore <candidate-text>', 'Ignore prompt files whose filename or first prompt line contains the given text (repeatable)', collectStringOption, []);
+        addCoderGitSyncOptions(command);
         command.action(handleActionErrors(async (cliOptions) => {
             const { reverse, ignore } = cliOptions;
+            const gitSync = normalizeCoderGitSyncCliOptions(cliOptions);
             // Note: Import the main function dynamically to avoid loading heavy dependencies until needed
             const { verifyPrompts } = await Promise.resolve().then(function () { return verifyPrompts$1; });
             try {
-                await verifyPrompts({ reverse, ignore });
+                await verifyPrompts({ reverse, ignore, gitSync });
             }
             catch (error) {
                 console.error(colors__default["default"].bgRed('Prompt verification failed:'), error);
@@ -44538,6 +44691,7 @@
      * - generate-boilerplates: Generate prompt boilerplate files
      * - find-refactor-candidates: Find files that need refactoring
      * - run: Run coding prompts with AI agents
+     * - ping: Test one harness and model with a tiny dummy prompt
      * - verify: Verify completed prompts
      * - find-fresh-emoji-tags: Find unused emoji tags
      *
@@ -44557,6 +44711,7 @@
             - find-refactor-candidates: Find files that need refactoring
             - find-unwritten: List prompt sections that still need to be authored
             - run: Run coding prompts with AI agents
+            - ping: Test the connection, response time and quota of one harness and model
             - server: Start a long-running coder server with a kanban web UI
             - verify: Verify completed prompts
             - find-fresh-emoji-tags: Find unused emoji tags
@@ -44568,6 +44723,7 @@
         $initializeCoderFindRefactorCandidatesCommand(coderCommand);
         $initializeCoderFindUnwrittenCommand(coderCommand);
         $initializeCoderRunCommand(coderCommand);
+        $initializeCoderPingCommand(coderCommand);
         $initializeCoderServerCommand(coderCommand);
         $initializeCoderVerifyCommand(coderCommand);
         $initializeCoderFindFreshEmojiTagCommand(coderCommand);
@@ -45401,6 +45557,14 @@
     // Note: [🟢] Code for Node file-cache storage [FileCacheStorage](src/storage/file-cache-storage/FileCacheStorage.ts) should never be published into packages that could be imported into browser environment
     // TODO: [🌗] Maybe some checkers, not all valid JSONs are desired and valid values
 
+    /**
+     * Loads the Socket.io client (`socket.io-client`) on demand
+     *
+     * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast
+     *
+     * @private internal utility of `createRemoteClient`
+     */
+    const loadSocketIoClientModule = createLazyModuleLoader(() => import('socket.io-client'));
     /**
      * Creates a connection to the remote proxy server.
      *
@@ -45429,8 +45593,9 @@
 
                     `));
         }
+        const { io } = await loadSocketIoClientModule();
         return new Promise((resolve, reject) => {
-            const socket = socket_ioClient.io(remoteServerUrl, {
+            const socket = io(remoteServerUrl, {
                 retries: CONNECTION_RETRIES_LIMIT,
                 timeout: CONNECTION_TIMEOUT_MS,
                 path: '/socket.io',
@@ -46096,7 +46261,8 @@
                           You will be logged in to ${remoteServerUrl}
                           If you don't have an account, it will be created automatically.
                       `)));
-                    const { username, password } = await prompts__default["default"]([
+                    const { default: prompts } = await loadPromptsModule();
+                    const { username, password } = await prompts([
                         {
                             type: 'text',
                             name: 'username',
@@ -46471,6 +46637,15 @@
     // TODO: Implement non-interactive login
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * Loads the ZIP archive library (`jszip`) on demand
+     *
+     * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast
+     *
+     * @private internal utility of `loadArchive` and `saveArchive`
+     */
+    const loadJsZipModule = createLazyModuleLoader(() => import('jszip'));
+
     /**
      * Loads the books from the archive file with `.bookc` extension
      *
@@ -46485,7 +46660,8 @@
             throw new UnexpectedError(`Archive file must have '.bookc' extension`);
         }
         const data = await fs.readFile(filePath);
-        const archive = await JSZip__default["default"].loadAsync(data);
+        const { default: JSZip } = await loadJsZipModule();
+        const archive = await JSZip.loadAsync(data);
         const indexFile = archive.file('index.book.json');
         if (!indexFile) {
             throw new UnexpectedError(`Archive does not contain 'index.book.json' file`);
@@ -50548,7 +50724,23 @@
         });
     }
 
-    // TODO: [🏳‍🌈] Finally take pick of .json vs .ts
+    /**
+     * Loads `jsdom` on demand
+     *
+     * Note: [🐌] `jsdom` is by far the heaviest dependency of Promptbook, loading it eagerly would slow down every single
+     *       run of the `ptbk` CLI utility even when no website is scraped
+     *
+     * @private internal utility of `WebsiteScraper`
+     */
+    const loadJsdomModule = createLazyModuleLoader(() => import('jsdom'));
+    /**
+     * Loads `@mozilla/readability` on demand
+     *
+     * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast
+     *
+     * @private internal utility of `WebsiteScraper`
+     */
+    const loadReadabilityModule = createLazyModuleLoader(() => import('@mozilla/readability'));
     /**
      * Scraper for websites
      *
@@ -50584,14 +50776,15 @@
             if (this.tools.fs === undefined) {
                 throw new EnvironmentMismatchError('Can not scrape websites without filesystem tools');
             }
-            const jsdom$1 = new jsdom.JSDOM(await source.asText(), {
+            const [{ JSDOM }, { Readability }] = await Promise.all([loadJsdomModule(), loadReadabilityModule()]);
+            const jsdom = new JSDOM(await source.asText(), {
                 url: source.url,
             });
-            const reader = new readability.Readability(jsdom$1.window.document);
+            const reader = new Readability(jsdom.window.document);
             const article = reader.parse();
             // console.log(article);
             // await forTime(10000);
-            let html = (article === null || article === void 0 ? void 0 : article.content) || (article === null || article === void 0 ? void 0 : article.textContent) || jsdom$1.window.document.body.innerHTML;
+            let html = (article === null || article === void 0 ? void 0 : article.content) || (article === null || article === void 0 ? void 0 : article.textContent) || jsdom.window.document.body.innerHTML;
             // Note: Unwrap html such as it is convertable by `markdownConverter`
             for (let i = 0; i < 2; i++) {
                 html = html.replace(/<div\s*(?:id="readability-page-\d+"\s+class="page")?>(.*)<\/div>/is, '$1');
@@ -50624,7 +50817,7 @@
                     throw error;
                 }
             }
-            const markdown = this.showdownConverter.makeMarkdown(html, jsdom$1.window.document);
+            const markdown = this.showdownConverter.makeMarkdown(html, jsdom.window.document);
             return { ...cacheFilehandler, markdown };
         }
         /**
@@ -54187,7 +54380,8 @@
         for (const pipelineJson of collectionJson) {
             validatePipeline(pipelineJson);
         }
-        const archive = new JSZip__default["default"]();
+        const { default: JSZip } = await loadJsZipModule();
+        const archive = new JSZip();
         const collectionJsonString = stringifyPipelineJson(collectionJson);
         archive.file('index.book.json', collectionJsonString);
         const data = await archive.generateAsync({ type: 'nodebuffer', streamFiles: true });
@@ -54815,7 +55009,8 @@
                 else {
                     console.info(colors__default["default"].gray(`---`));
                 }
-                const response = await prompts__default["default"]({
+                const { default: prompts } = await loadPromptsModule();
+                const response = await prompts({
                     type: 'text',
                     name: 'userMessage',
                     message: 'User message',
@@ -55122,7 +55317,8 @@
         if (pipelineSource) {
             return pipelineSource;
         }
-        const response = await prompts__default["default"]({
+        const { default: prompts } = await loadPromptsModule();
+        const response = await prompts({
             type: 'text',
             name: 'pipelineSource',
             message: '',
@@ -55209,7 +55405,8 @@
             console.error(colors__default["default"].red(createRunMissingInputParametersMessage(pipeline, inputParameters, questions)));
             return process.exit(1);
         }
-        const response = await prompts__default["default"](questions);
+        const { default: prompts } = await loadPromptsModule();
+        const response = await prompts(questions);
         //                     <- TODO: [🧠][🍼] Change behavior according to the formfactor
         return { ...inputParameters, ...response };
         //      <- TODO: Maybe do some validation of the response (and --json argument which is passed)
@@ -58114,6 +58311,14 @@
         fullname: 'Anthropic Claude',
         color: '#d97706',
     };
+    /**
+     * Loads the Anthropic Claude SDK (`@anthropic-ai/sdk`) on demand
+     *
+     * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast
+     *
+     * @private internal utility of `AnthropicClaudeExecutionTools`
+     */
+    const loadAnthropicClaudeModule = createLazyModuleLoader(() => import('@anthropic-ai/sdk'));
     /**
      * Execution Tools for calling Anthropic Claude API.
      *
@@ -58151,7 +58356,8 @@
                 const anthropicOptions = { ...this.options };
                 delete anthropicOptions.isVerbose;
                 delete anthropicOptions.isProxied;
-                this.client = new Anthropic__default["default"](anthropicOptions);
+                const { Anthropic } = await loadAnthropicClaudeModule();
+                this.client = new Anthropic(anthropicOptions);
             }
             return this.client;
         }
@@ -58414,6 +58620,14 @@
         fullname: 'Azure OpenAI',
         color: '#0078d4',
     };
+    /**
+     * Loads the Azure OpenAI SDK (`@azure/openai`) on demand
+     *
+     * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast
+     *
+     * @private internal utility of `AzureOpenAiExecutionTools`
+     */
+    const loadAzureOpenAiModule = createLazyModuleLoader(() => import('@azure/openai'));
     /**
      * Execution Tools for calling Azure OpenAI API.
      *
@@ -58447,7 +58661,8 @@
         }
         async getClient() {
             if (this.client === null) {
-                this.client = new openai.OpenAIClient(`https://${this.options.resourceName}.openai.azure.com/`, new openai.AzureKeyCredential(this.options.apiKey));
+                const { AzureKeyCredential, OpenAIClient } = await loadAzureOpenAiModule();
+                this.client = new OpenAIClient(`https://${this.options.resourceName}.openai.azure.com/`, new AzureKeyCredential(this.options.apiKey));
             }
             return this.client;
         }
@@ -60256,6 +60471,14 @@
         }
     }
 
+    /**
+     * Loads the OpenAI SDK (`openai`) on demand
+     *
+     * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast
+     *
+     * @private internal utility of `OpenAiCompatibleRequestManager`
+     */
+    const loadOpenAiModule = createLazyModuleLoader(() => import('openai'));
     /**
      * Manages OpenAI-compatible client creation plus shared retry and rate-limit behavior.
      *
@@ -60282,7 +60505,8 @@
                     timeout: API_REQUEST_TIMEOUT,
                     maxRetries: CONNECTION_RETRIES_LIMIT,
                 };
-                this.client = new OpenAI__default["default"](enhancedOptions);
+                const { default: OpenAI } = await loadOpenAiModule();
+                this.client = new OpenAI(enhancedOptions);
             }
             return this.client;
         }
@@ -67995,8 +68219,9 @@
         if (options.isVerbose) {
             console.info(colors__default["default"].gray('Type "exit" or "quit" to end the chat.'));
         }
+        const { default: prompts } = await loadPromptsModule();
         while (true) {
-            const response = await prompts__default["default"]({
+            const response = await prompts({
                 type: 'text',
                 name: 'userMessage',
                 message: 'User message',
@@ -69208,6 +69433,16 @@
         }
     }
 
+    /**
+     * Loads the OpenAI AgentKit SDK (`@openai/agents`) on demand
+     *
+     * Note: [🐌] The AgentKit SDK is one of the heaviest dependencies of Promptbook, loading it eagerly would slow down
+     *       every single run of the `ptbk` CLI utility even when no AgentKit agent is used
+     *
+     * @private internal utility of `@promptbook/openai`
+     */
+    const loadOpenAiAgentsModule = createLazyModuleLoader(() => import('@openai/agents'));
+
     /**
      * Constant for default model used for nested DeepSearch tool invocations.
      */
@@ -69261,11 +69496,12 @@
         /**
          * Builds the tool list for AgentKit, including hosted file search when applicable.
          */
-        buildAgentKitTools(options) {
+        async buildAgentKitTools(options) {
             const { tools, vectorStoreId } = options;
+            const { fileSearchTool, tool: agentKitTool } = await loadOpenAiAgentsModule();
             const agentKitTools = [];
             if (vectorStoreId) {
-                agentKitTools.push(agents.fileSearchTool(vectorStoreId));
+                agentKitTools.push(fileSearchTool(vectorStoreId));
             }
             if (!tools || tools.length === 0) {
                 return agentKitTools;
@@ -69273,11 +69509,11 @@
             let scriptTools = null;
             for (const toolDefinition of tools) {
                 if (this.isDeepSearchToolDefinition(toolDefinition)) {
-                    agentKitTools.push(this.createDeepSearchAgentKitTool(toolDefinition));
+                    agentKitTools.push(await this.createDeepSearchAgentKitTool(toolDefinition));
                     continue;
                 }
                 scriptTools !== null && scriptTools !== void 0 ? scriptTools : (scriptTools = this.resolveScriptTools());
-                agentKitTools.push(agents.tool({
+                agentKitTools.push(agentKitTool({
                     name: toolDefinition.name,
                     description: toolDefinition.description,
                     parameters: this.normalizeAgentKitToolParameters(toolDefinition.parameters),
@@ -69484,12 +69720,13 @@
         /**
          * Creates the native Agent SDK tool used for `USE DEEPSEARCH`.
          */
-        createDeepSearchAgentKitTool(toolDefinition) {
-            const deepSearchAgent = new agents.Agent({
+        async createDeepSearchAgentKitTool(toolDefinition) {
+            const { Agent: AgentFromKit, webSearchTool } = await loadOpenAiAgentsModule();
+            const deepSearchAgent = new AgentFromKit({
                 name: 'DeepSearch',
                 model: DEFAULT_DEEP_SEARCH_MODEL_NAME,
                 instructions: this.createDeepSearchAgentInstructions(toolDefinition.description),
-                tools: [agents.webSearchTool({ searchContextSize: 'high' })],
+                tools: [webSearchTool({ searchContextSize: 'high' })],
             });
             return deepSearchAgent.asTool({
                 toolName: toolDefinition.name,
@@ -69698,8 +69935,9 @@
                     vectorStoreId,
                 });
             }
-            const agentKitTools = this.buildAgentKitTools({ tools, vectorStoreId });
-            const openAiAgentKitAgent = new agents.Agent({
+            const { Agent: AgentFromKit } = await loadOpenAiAgentsModule();
+            const agentKitTools = await this.buildAgentKitTools({ tools, vectorStoreId });
+            const openAiAgentKitAgent = new AgentFromKit({
                 name,
                 model: this.agentKitModelName,
                 instructions: instructions || 'You are a helpful assistant.',
@@ -69744,7 +69982,8 @@
                 agentName: agentForRun.name,
                 input: inputItems,
             };
-            const streamResult = await agents.run(agentForRun, inputItems, {
+            const { run } = await loadOpenAiAgentsModule();
+            const streamResult = await run(agentForRun, inputItems, {
                 stream: true,
                 maxTurns: 200,
                 context: {
@@ -69886,11 +70125,12 @@
          * Ensures the AgentKit SDK is wired to the OpenAI client and API key.
          */
         async ensureAgentKitDefaults() {
+            const { setDefaultOpenAIClient, setDefaultOpenAIKey } = await loadOpenAiAgentsModule();
             const client = await this.getClient();
-            agents.setDefaultOpenAIClient(client);
+            setDefaultOpenAIClient(client);
             const apiKey = this.agentKitOptions.apiKey;
             if (apiKey && typeof apiKey === 'string') {
-                agents.setDefaultOpenAIKey(apiKey);
+                setDefaultOpenAIKey(apiKey);
             }
         }
         /**
@@ -72218,6 +72458,66 @@
         RemoteAgent: RemoteAgent
     });
 
+    /**
+     * Git synchronization which leaves the repository completely untouched.
+     *
+     * Note: This is the default for every command and helper which supports the git synchronization.
+     */
+    const DISABLED_CODER_GIT_SYNC_OPTIONS = Object.freeze({
+        isCommitEnabled: false,
+        isAutoPushEnabled: false,
+        isAutoPullEnabled: false,
+    });
+    /**
+     * Pulls the latest repository changes before a `ptbk coder` command changes the project.
+     */
+    async function $pullCoderChanges(options) {
+        const { gitSync, projectPath = process.cwd() } = options;
+        if (!gitSync.isAutoPullEnabled) {
+            return;
+        }
+        console.info(colors__default["default"].gray('Pulling the latest changes from the remote repository...'));
+        await pullLatestChanges(projectPath);
+    }
+    /**
+     * Commits - and when requested also pushes - the changes one `ptbk coder` command has just made.
+     *
+     * Note: A repository without any change is left alone instead of creating an empty commit.
+     */
+    async function $commitCoderChanges(options) {
+        const { gitSync, commitMessage, projectPath = process.cwd() } = options;
+        if (!gitSync.isCommitEnabled) {
+            return;
+        }
+        if (!(await hasChangesToCommit(projectPath))) {
+            console.info(colors__default["default"].gray('Nothing to commit, the working tree is clean'));
+            return;
+        }
+        await commitChanges(commitMessage, {
+            projectPath,
+            autoPush: gitSync.isAutoPushEnabled,
+        });
+        console.info(colors__default["default"].green(`✓ ${gitSync.isAutoPushEnabled ? 'Committed and pushed' : 'Committed'}: ${commitMessage}`));
+    }
+    /**
+     * Checks whether the repository holds any change which can be committed.
+     */
+    async function hasChangesToCommit(projectPath) {
+        const gitStatus = await runGitCommand({
+            command: 'git status --porcelain',
+            cwd: projectPath,
+            isVerbose: false,
+        });
+        return gitStatus.trim() !== '';
+    }
+
+    var coderGitSync = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        DISABLED_CODER_GIT_SYNC_OPTIONS: DISABLED_CODER_GIT_SYNC_OPTIONS,
+        $pullCoderChanges: $pullCoderChanges,
+        $commitCoderChanges: $commitCoderChanges
+    });
+
     /**
      * Calculates the next available prompt numbering sequence for a month.
      */
@@ -72692,6 +72992,31 @@
     }
     // Note: [🟡] Code for repository script [normalizeRefactorCandidatePath](scripts/find-refactor-candidates/normalizeRefactorCandidatePath.ts) should never be published outside of `@promptbook/cli`
 
+    /**
+     * The TypeScript compiler API once it was loaded by `analyzeSourceFileForRefactorCandidate`
+     *
+     * Note: [🐌] `typescript` is a heavy package, it is loaded on demand so that it does not slow down every single run
+     *       of the `ptbk` CLI utility
+     *
+     * @private variable of analyzeSourceFileForRefactorCandidate
+     */
+    let loadedTypescriptModule = null;
+    /**
+     * Returns the TypeScript compiler API which was already loaded for the structural analysis.
+     *
+     * @private function of analyzeSourceFileForRefactorCandidate
+     */
+    function getLoadedTypescriptModule() {
+        if (loadedTypescriptModule === null) {
+            throw new UnexpectedError(spaceTrim(`
+                The \`typescript\` module was not loaded yet.
+
+                Structural analysis helpers must be called only from \`analyzeSourceFileForRefactorCandidate\` which
+                loads \`typescript\` lazily.
+            `));
+        }
+        return loadedTypescriptModule;
+    }
     /**
      * Resolves whether a source file should produce a refactor candidate entry.
      *
@@ -72717,6 +73042,7 @@
             }
         }
         if (STRUCTURAL_ANALYSIS_EXTENSIONS.includes(extension)) {
+            loadedTypescriptModule !== null && loadedTypescriptModule !== void 0 ? loadedTypescriptModule : (loadedTypescriptModule = await getTypescriptModule());
             const structureSummary = summarizeSourceFileStructure(content, extension, filePath);
             if (structureSummary.entityCount > heuristics.maxEntityCountPerFile) {
                 reasons.push(`entities ${structureSummary.entityCount}/${heuristics.maxEntityCountPerFile}`);
@@ -72776,8 +73102,9 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function summarizeSourceFileStructure(content, extension, filePath) {
+        const ts = getLoadedTypescriptModule();
         const scriptKind = getScriptKindForExtension(extension);
-        const sourceFile = ts__namespace.createSourceFile(filePath, content, ts__namespace.ScriptTarget.Latest, true, scriptKind);
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, scriptKind);
         return {
             entityCount: countEntitiesInSourceFile(sourceFile),
             ...summarizeFunctionsInSourceFile(sourceFile),
@@ -72789,25 +73116,26 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function countEntitiesInSourceFile(sourceFile) {
+        const ts = getLoadedTypescriptModule();
         let count = 0;
         // Only count top-level declarations to avoid inflating with members or nested scopes.
         for (const statement of sourceFile.statements) {
-            if (ts__namespace.isFunctionDeclaration(statement) ||
-                ts__namespace.isClassDeclaration(statement) ||
-                ts__namespace.isInterfaceDeclaration(statement) ||
-                ts__namespace.isTypeAliasDeclaration(statement) ||
-                ts__namespace.isEnumDeclaration(statement) ||
-                ts__namespace.isModuleDeclaration(statement)) {
+            if (ts.isFunctionDeclaration(statement) ||
+                ts.isClassDeclaration(statement) ||
+                ts.isInterfaceDeclaration(statement) ||
+                ts.isTypeAliasDeclaration(statement) ||
+                ts.isEnumDeclaration(statement) ||
+                ts.isModuleDeclaration(statement)) {
                 count += 1;
                 continue;
             }
-            if (ts__namespace.isVariableStatement(statement)) {
+            if (ts.isVariableStatement(statement)) {
                 for (const declaration of statement.declarationList.declarations) {
                     const initializer = declaration.initializer;
                     if (initializer &&
-                        (ts__namespace.isArrowFunction(initializer) ||
-                            ts__namespace.isFunctionExpression(initializer) ||
-                            ts__namespace.isClassExpression(initializer))) {
+                        (ts.isArrowFunction(initializer) ||
+                            ts.isFunctionExpression(initializer) ||
+                            ts.isClassExpression(initializer))) {
                         count += 1;
                     }
                 }
@@ -72821,6 +73149,7 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function summarizeFunctionsInSourceFile(sourceFile) {
+        const ts = getLoadedTypescriptModule();
         let functionCount = 0;
         let maxFunctionComplexity = 0;
         let mostComplexFunctionName = null;
@@ -72833,7 +73162,7 @@
                     mostComplexFunctionName = getFunctionDisplayName(node);
                 }
             }
-            ts__namespace.forEachChild(node, visitNode);
+            ts.forEachChild(node, visitNode);
         };
         visitNode(sourceFile);
         return {
@@ -72848,14 +73177,15 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function isCountedFunctionLikeDeclaration(node) {
-        if (ts__namespace.isFunctionDeclaration(node) ||
-            ts__namespace.isMethodDeclaration(node) ||
-            ts__namespace.isConstructorDeclaration(node) ||
-            ts__namespace.isGetAccessorDeclaration(node) ||
-            ts__namespace.isSetAccessorDeclaration(node)) {
+        const ts = getLoadedTypescriptModule();
+        if (ts.isFunctionDeclaration(node) ||
+            ts.isMethodDeclaration(node) ||
+            ts.isConstructorDeclaration(node) ||
+            ts.isGetAccessorDeclaration(node) ||
+            ts.isSetAccessorDeclaration(node)) {
             return true;
         }
-        if (ts__namespace.isArrowFunction(node) || ts__namespace.isFunctionExpression(node)) {
+        if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
             return isNamedFunctionExpression(node);
         }
         return false;
@@ -72866,8 +73196,9 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function isNamedFunctionExpression(node) {
+        const ts = getLoadedTypescriptModule();
         const parent = node.parent;
-        return (ts__namespace.isVariableDeclaration(parent) || ts__namespace.isPropertyDeclaration(parent) || ts__namespace.isPropertyAssignment(parent));
+        return (ts.isVariableDeclaration(parent) || ts.isPropertyDeclaration(parent) || ts.isPropertyAssignment(parent));
     }
     /**
      * Calculates a lightweight cyclomatic-complexity score for one function.
@@ -72878,6 +73209,7 @@
         if (!functionNode.body) {
             return 1;
         }
+        const ts = getLoadedTypescriptModule();
         let complexity = 1;
         const visitNode = (node) => {
             if (node !== functionNode.body && isCountedFunctionLikeDeclaration(node)) {
@@ -72886,7 +73218,7 @@
             if (isComplexityDecisionNode(node)) {
                 complexity += 1;
             }
-            ts__namespace.forEachChild(node, visitNode);
+            ts.forEachChild(node, visitNode);
         };
         visitNode(functionNode.body);
         return complexity;
@@ -72897,22 +73229,23 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function isComplexityDecisionNode(node) {
-        if (ts__namespace.isIfStatement(node) ||
-            ts__namespace.isConditionalExpression(node) ||
-            ts__namespace.isCatchClause(node) ||
-            ts__namespace.isForStatement(node) ||
-            ts__namespace.isForInStatement(node) ||
-            ts__namespace.isForOfStatement(node) ||
-            ts__namespace.isWhileStatement(node) ||
-            ts__namespace.isDoStatement(node) ||
-            ts__namespace.isCaseClause(node)) {
+        const ts = getLoadedTypescriptModule();
+        if (ts.isIfStatement(node) ||
+            ts.isConditionalExpression(node) ||
+            ts.isCatchClause(node) ||
+            ts.isForStatement(node) ||
+            ts.isForInStatement(node) ||
+            ts.isForOfStatement(node) ||
+            ts.isWhileStatement(node) ||
+            ts.isDoStatement(node) ||
+            ts.isCaseClause(node)) {
             return true;
         }
-        if (ts__namespace.isBinaryExpression(node)) {
+        if (ts.isBinaryExpression(node)) {
             const operatorKind = node.operatorToken.kind;
-            return (operatorKind === ts__namespace.SyntaxKind.AmpersandAmpersandToken ||
-                operatorKind === ts__namespace.SyntaxKind.BarBarToken ||
-                operatorKind === ts__namespace.SyntaxKind.QuestionQuestionToken);
+            return (operatorKind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                operatorKind === ts.SyntaxKind.BarBarToken ||
+                operatorKind === ts.SyntaxKind.QuestionQuestionToken);
         }
         return false;
     }
@@ -72922,27 +73255,28 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function getFunctionDisplayName(functionNode) {
-        if (ts__namespace.isConstructorDeclaration(functionNode)) {
+        const ts = getLoadedTypescriptModule();
+        if (ts.isConstructorDeclaration(functionNode)) {
             return 'constructor';
         }
-        if (ts__namespace.isFunctionDeclaration(functionNode) ||
-            ts__namespace.isMethodDeclaration(functionNode) ||
-            ts__namespace.isGetAccessorDeclaration(functionNode) ||
-            ts__namespace.isSetAccessorDeclaration(functionNode)) {
+        if (ts.isFunctionDeclaration(functionNode) ||
+            ts.isMethodDeclaration(functionNode) ||
+            ts.isGetAccessorDeclaration(functionNode) ||
+            ts.isSetAccessorDeclaration(functionNode)) {
             if (!functionNode.name) {
                 return null;
             }
             return getPropertyNameText(functionNode.name);
         }
-        if (ts__namespace.isArrowFunction(functionNode) || ts__namespace.isFunctionExpression(functionNode)) {
+        if (ts.isArrowFunction(functionNode) || ts.isFunctionExpression(functionNode)) {
             if (functionNode.name) {
                 return functionNode.name.text;
             }
             const parent = functionNode.parent;
-            if (ts__namespace.isVariableDeclaration(parent)) {
+            if (ts.isVariableDeclaration(parent)) {
                 return getBindingNameText(parent.name);
             }
-            if (ts__namespace.isPropertyDeclaration(parent) || ts__namespace.isPropertyAssignment(parent)) {
+            if (ts.isPropertyDeclaration(parent) || ts.isPropertyAssignment(parent)) {
                 return getPropertyNameText(parent.name);
             }
         }
@@ -72954,7 +73288,8 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function getBindingNameText(name) {
-        return ts__namespace.isIdentifier(name) ? name.text : null;
+        const ts = getLoadedTypescriptModule();
+        return ts.isIdentifier(name) ? name.text : null;
     }
     /**
      * Resolves text for a property name while preserving computed names when necessary.
@@ -72962,7 +73297,8 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function getPropertyNameText(name) {
-        if (ts__namespace.isIdentifier(name) || ts__namespace.isPrivateIdentifier(name) || ts__namespace.isStringLiteral(name) || ts__namespace.isNumericLiteral(name)) {
+        const ts = getLoadedTypescriptModule();
+        if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
             return name.text;
         }
         return name.getText();
@@ -72984,16 +73320,17 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function getScriptKindForExtension(extension) {
+        const ts = getLoadedTypescriptModule();
         if (extension === '.tsx') {
-            return ts__namespace.ScriptKind.TSX;
+            return ts.ScriptKind.TSX;
         }
         if (extension === '.jsx') {
-            return ts__namespace.ScriptKind.JSX;
+            return ts.ScriptKind.JSX;
         }
         if (extension === '.js') {
-            return ts__namespace.ScriptKind.JS;
+            return ts.ScriptKind.JS;
         }
-        return ts__namespace.ScriptKind.TS;
+        return ts.ScriptKind.TS;
     }
     /**
      * Normalizes an absolute path for consistent comparisons.
@@ -73593,6 +73930,41 @@
             isPromptInPriorityFilter(prompt.section, priorityFilter));
     }
 
+    /**
+     * Checks whether a prompt is unrestricted or matches the selected harness/model.
+     *
+     * A prompt status line can contain one or more backtick-delimited model or harness
+     * names. Matching is intentionally based on normalized substrings so a token such as
+     * `gpt` selects any `gpt-*` model and `opus` selects a `claude-opus-*` model.
+     */
+    function isPromptCompatibleWithRunner(file, section, promptRunnerIdentity) {
+        if (promptRunnerIdentity === undefined) {
+            return true;
+        }
+        const statusLine = section.statusLineIndex === undefined ? undefined : file.lines[section.statusLineIndex];
+        const requiredRunnerTokens = statusLine === undefined ? [] : extractPromptRunnerTokens(statusLine);
+        if (requiredRunnerTokens.length === 0) {
+            return true;
+        }
+        const normalizedRunnerNames = [promptRunnerIdentity.harnessName, promptRunnerIdentity.modelName]
+            .filter((name) => name !== undefined && name.trim() !== '')
+            .map((name) => normalizeToKebabCase(name))
+            .filter((name) => name !== '');
+        return requiredRunnerTokens.some((requiredRunnerToken) => {
+            const normalizedRequiredRunnerToken = normalizeToKebabCase(requiredRunnerToken);
+            return (normalizedRequiredRunnerToken !== '' &&
+                normalizedRunnerNames.some((normalizedRunnerName) => normalizedRunnerName.includes(normalizedRequiredRunnerToken)));
+        });
+    }
+    /**
+     * Extracts model and harness tokens from a prompt status line.
+     */
+    function extractPromptRunnerTokens(statusLine) {
+        return Array.from(statusLine.matchAll(/`([^`]+)`/gu))
+            .map((match) => { var _a, _b; return (_b = (_a = match[1]) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : ''; })
+            .filter((token) => token !== '');
+    }
+
     /**
      * Parses a prompt markdown file into sections and metadata.
      */
@@ -73640,11 +74012,11 @@
         };
     }
     /**
-     * Parses a status line like "[ ] !!" or "[-]" or "[x] ~$0.65 21 minutes..." into status and priority.
+     * Parses a status line like "[ ] !!", "[ ] use `gpt` !!!!!" or "[-]" into status and priority.
      * For [x] done and [!] failed prompts, allow metadata after the status marker.
      */
     function parseStatusLine(line) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         // For done prompts [x], allow any content after (for cost/time metadata)
         const doneMatch = line.match(/^\[(?<status>[xX])\]/);
         if (doneMatch) {
@@ -73655,21 +74027,23 @@
         if (failedMatch) {
             return { status: 'failed', priority: 0 };
         }
-        // For todo [ ] and not-ready [-], require clean end with optional priority markers
-        const match = line.match(/^\[(?<status>[ -])\]\s*(?<priority>!*)\s*$/);
-        if (!match) {
-            return undefined;
+        // For not-ready [-], keep the historical clean-line syntax.
+        if (/^\[-\]\s*!*\s*$/u.test(line)) {
+            return { status: 'not-ready', priority: 0 };
         }
-        const statusChar = (_b = (_a = match.groups) === null || _a === void 0 ? void 0 : _a.status) === null || _b === void 0 ? void 0 : _b.toLowerCase();
-        let status;
-        if (statusChar === '-') {
-            status = 'not-ready';
+        // Todo [ ] may contain backtick-delimited model/harness tokens and priority markers
+        // before or after those tokens. Other trailing text remains an invalid status line.
+        const todoMatch = line.match(/^\[ \](?<details>.*)$/u);
+        if (!todoMatch) {
+            return undefined;
         }
-        else {
-            status = 'todo';
+        const details = (_b = (_a = todoMatch.groups) === null || _a === void 0 ? void 0 : _a.details) !== null && _b !== void 0 ? _b : '';
+        const isPriorityOnly = /^[!\s]*$/u.test(details);
+        const hasPromptRunnerTokens = extractPromptRunnerTokens(line).length > 0;
+        if (details.trim() !== '' && !isPriorityOnly && !hasPromptRunnerTokens) {
+            return undefined;
         }
-        const priority = status === 'todo' ? (_e = (_d = (_c = match.groups) === null || _c === void 0 ? void 0 : _c.priority) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0 : 0;
-        return { status, priority };
+        return { status: 'todo', priority: (_d = (_c = details.match(/!/gu)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0 };
     }
     /**
      * Finds the first non-empty line index between two bounds.
@@ -73805,6 +74179,243 @@
         findUnwrittenPrompts: findUnwrittenPrompts
     });
 
+    /**
+     * Builds a normalized temporary shell script path for prompt runners.
+     */
+    function buildTemporaryPromptScriptPath(options) {
+        const sourceFileName = path.basename(options.sourceFileName);
+        const scriptFileName = `${sourceFileName.replace(/\.[^.]+$/u, '')}${options.suffix || ''}.sh`;
+        return resolvePromptbookTemporaryPath(options.projectPath, options.scriptDirectoryName, scriptFileName);
+    }
+
+    /**
+     * Marker the pinged harness is asked to prefix its answer with, so the reply can be recognized
+     * in the raw runner output of every supported harness.
+     *
+     * Note: The marker must stay free of regular-expression metacharacters, because
+     *       `extractCoderPingAnswer` builds its pattern from it.
+     */
+    const CODER_PING_ANSWER_MARKER = 'PTBK-CODER-PING-ANSWER';
+    /**
+     * First factor of the dummy multiplication the pinged harness is asked to compute.
+     */
+    const CODER_PING_FIRST_FACTOR = 6;
+    /**
+     * Second factor of the dummy multiplication the pinged harness is asked to compute.
+     */
+    const CODER_PING_SECOND_FACTOR = 7;
+    /**
+     * Answer a working harness and model returns for the dummy work of `ptbk coder ping`.
+     */
+    const CODER_PING_EXPECTED_ANSWER = String(CODER_PING_FIRST_FACTOR * CODER_PING_SECOND_FACTOR);
+    /**
+     * Builds the dummy prompt sent by `ptbk coder ping`.
+     *
+     * The work is intentionally the smallest possible one that still reaches the model: it spends a
+     * negligible amount of the harness quota, it needs no tool and it explicitly forbids touching the
+     * project, so a ping leaves the project exactly as it was.
+     */
+    function buildCoderPingPrompt() {
+        return spaceTrim(`
+        # Promptbook connection check
+
+        This is an automated \`ptbk coder ping\` connection check, not a coding task.
+
+        Do exactly this and nothing else:
+
+        1. Multiply \`${CODER_PING_FIRST_FACTOR}\` by \`${CODER_PING_SECOND_FACTOR}\`.
+        2. Answer with one single line \`${CODER_PING_ANSWER_MARKER}: <result>\` where \`<result>\` is the number you computed.
+
+        Rules:
+
+        - Do not read, create, change, move or delete any file.
+        - Do not run any command and do not use any tool.
+        - Do not write anything except the single answer line.
+    `);
+    }
+
+    /**
+     * Pattern matching one answer line produced by the pinged harness.
+     *
+     * The captured answer deliberately stops at a quote, a backslash or a line break, so an answer
+     * embedded in a JSON event stream — as produced by Claude Code, Opencode or Codex `--json` — is
+     * captured without the surrounding JSON.
+     */
+    const CODER_PING_ANSWER_PATTERN = new RegExp(`${CODER_PING_ANSWER_MARKER}\\s*:[ \\t]*([^\\r\\n"\\\\]*)`, 'gu');
+    /**
+     * Extracts the answer of a pinged harness from the runtime log of its runner shell.
+     *
+     * Only the raw output of the last execution is searched, so the answer marker contained in the
+     * prompt of the raw input is never mistaken for the answer of the harness.
+     *
+     * @returns The answer of the harness, or `null` when the harness produced no recognizable answer
+     */
+    function extractCoderPingAnswer(runtimeLog) {
+        var _a;
+        const rawOutput = runtimeLog.split(SCRIPT_EXECUTION_LOG_RAW_OUTPUT_MARKER).pop();
+        if (rawOutput === undefined) {
+            return null;
+        }
+        // Note: The last answer wins because harnesses which stream partial messages repeat the growing answer line
+        const answers = Array.from(rawOutput.matchAll(CODER_PING_ANSWER_PATTERN))
+            .map((match) => (match[1] || '').trim())
+            .filter((answer) => answer !== '');
+        return (_a = answers[answers.length - 1]) !== null && _a !== void 0 ? _a : null;
+    }
+
+    /**
+     * Temporary subdirectory used for the `ptbk coder ping` runner shell script and its runtime log.
+     */
+    const CODER_PING_SCRIPT_DIRECTORY_NAME = 'coder-ping';
+    /**
+     * Base name of the temporary `ptbk coder ping` runner shell script.
+     */
+    const CODER_PING_SCRIPT_SOURCE_NAME = 'ping';
+    /**
+     * Sends one tiny dummy prompt through the selected harness and model and measures the round trip.
+     *
+     * The ping reuses the very same runner the coding queue uses, so it really exercises the configured
+     * harness, model, thinking level and authentication — including the retry behavior on rate limits.
+     * Both temporary artifacts it creates are removed again, so the project is left as it was.
+     */
+    async function pingCoderHarness(options) {
+        const projectPath = options.projectPath || process.cwd();
+        const { runner, runnerMetadata } = resolvePromptRunner(options);
+        const scriptPath = buildTemporaryPromptScriptPath({
+            projectPath,
+            scriptDirectoryName: CODER_PING_SCRIPT_DIRECTORY_NAME,
+            sourceFileName: CODER_PING_SCRIPT_SOURCE_NAME,
+        });
+        const startedTimeMs = Date.now();
+        const { answer, usage, loginMethod } = await withPromptRuntimeLog(scriptPath, async (logPath) => {
+            var _a;
+            const result = await runner.runPrompt({
+                prompt: buildCoderPingPrompt(),
+                scriptPath,
+                projectPath,
+                logPath,
+                shouldPrintLiveOutput: (_a = options.shouldPrintLiveOutput) !== null && _a !== void 0 ? _a : false,
+                preserveArtifactsOnSuccess: false,
+            });
+            return { ...result, answer: extractCoderPingAnswer(await readRuntimeLog(logPath)) };
+        }, { preserveArtifactsOnSuccess: false });
+        return {
+            runnerName: runnerMetadata.runnerName,
+            modelName: runnerMetadata.modelName,
+            thinkingLevel: options.thinkingLevel,
+            answer,
+            isAnswerCorrect: answer === CODER_PING_EXPECTED_ANSWER,
+            durationMs: Date.now() - startedTimeMs,
+            usage,
+            loginMethod,
+        };
+    }
+    /**
+     * Reads the runtime log of the finished ping, treating an unreadable log as no output at all.
+     */
+    async function readRuntimeLog(logPath) {
+        return await promises.readFile(logPath, 'utf-8').catch(() => '');
+    }
+
+    var pingCoderHarness$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        pingCoderHarness: pingCoderHarness
+    });
+
+    /**
+     * Formats usage price for display in prompt status lines and task details.
+     * Examples:
+     * - "$0.12" (certain)
+     * - "~$3.05" (uncertain)
+     * - "$0.00" (zero cost)
+     * - "<$0.01" (tiny non-zero cost)
+     *
+     * @private internal utility of the prompt runners and the Agents Server task details
+     */
+    function formatUsagePrice(usage) {
+        const price = usage.price.value;
+        const isUncertain = usage.price.isUncertain === true;
+        const prefix = isUncertain ? '~' : '';
+        if (price === 0) {
+            return `${prefix}$0.00`;
+        }
+        if (price < 0.01) {
+            return `${prefix}<$0.01`;
+        }
+        if (price < 1) {
+            return `${prefix}$${price.toFixed(4)}`;
+        }
+        return `${prefix}$${price.toFixed(2)}`;
+    }
+
+    /**
+     * Formats runner details for prompt status lines.
+     */
+    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}\`` : '';
+        if (!normalizedRunner && !normalizedModel) {
+            return 'unknown';
+        }
+        const runnerLabel = normalizedRunner || 'unknown';
+        if (!normalizedModel) {
+            return `${runnerLabel}${thinkingLevelSuffix}`;
+        }
+        return `${runnerLabel} \`${normalizedModel}\`${thinkingLevelSuffix}`;
+    }
+
+    /**
+     * Prints the compact summary of one finished `ptbk coder ping`.
+     */
+    function printCoderPingResult(result) {
+        const runnerSignature = formatRunnerSignature(result.runnerName, result.modelName, 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)}`));
+        console.info(colors__default["default"].gray(`   Answer: ${formatCoderPingAnswer(result)}`));
+        console.info(colors__default["default"].gray(`   Usage:  ${formatCoderPingUsage(result.usage)}`));
+    }
+    /**
+     * Formats the measured round-trip time, keeping the sub-second precision a response time needs.
+     */
+    function formatCoderPingResponseTime(durationMs) {
+        return `${(durationMs / 1000).toFixed(2)}s`;
+    }
+    /**
+     * Formats the answer of the pinged harness together with what was expected from it.
+     */
+    function formatCoderPingAnswer(result) {
+        if (result.answer === null) {
+            return `Reached, but the answer line was missing from the output (expected \`${CODER_PING_EXPECTED_ANSWER}\`)`;
+        }
+        if (result.isAnswerCorrect) {
+            return result.answer;
+        }
+        return `${result.answer} (expected \`${CODER_PING_EXPECTED_ANSWER}\`)`;
+    }
+    /**
+     * Formats the resources the pinged harness reported for the dummy work.
+     */
+    function formatCoderPingUsage(usage) {
+        return [
+            formatUsagePrice(usage),
+            `${formatUncertainCount(usage.input.tokensCount)} input tokens`,
+            `${formatUncertainCount(usage.output.tokensCount)} output tokens`,
+        ].join(', ');
+    }
+    /**
+     * Formats one counted usage value, marking an estimated count with a leading `~`.
+     */
+    function formatUncertainCount(count) {
+        return `${count.isUncertain === true ? '~' : ''}${Math.round(count.value)}`;
+    }
+
+    var printCoderPingResult$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        printCoderPingResult: printCoderPingResult
+    });
+
     /**
      * Default wait duration applied before retrying a failed prompt round.
      */
@@ -73812,7 +74423,7 @@
     /**
      * CLI usage text for this script.
      */
-    const USAGE = 'Usage: run-codex-prompts [--dry-run] [--harness <harness-name>] [--model <model>] [--context <context-or-file>] [--test <test-command...>] [--preserve-logs] [--isolate] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--min-priority <minimum-priority>] [--max-priority <maximum-priority>] [--limit <run-count>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--wait-after-prompt <duration>] [--wait-between-prompts <duration>] [--wait-after-error <duration>] [--no-auto] [--no-commit] [--ignore-git-changes] [--no-normalize-line-endings] [--auto-push] [--auto-pull]';
+    const USAGE = 'Usage: run-codex-prompts [--dry-run] [--harness <harness-name>] [--model <model>] [--context <context-or-file>] [--test <test-command...>] [--test-before <no|yes-and-fail|yes-and-fix>] [--preserve-logs] [--isolate] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--min-priority <minimum-priority>] [--max-priority <maximum-priority>] [--limit <run-count>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--wait-after-prompt <duration>] [--wait-between-prompts <duration>] [--wait-after-error <duration>] [--no-auto] [--no-commit] [--ignore-git-changes] [--no-normalize-line-endings] [--auto-push] [--auto-pull]';
     /**
      * Top-level flags supported by this command.
      */
@@ -73822,6 +74433,7 @@
         '--model',
         '--context',
         '--test',
+        '--test-before',
         '--preserve-logs',
         '--isolate',
         '--no-ui',
@@ -73860,6 +74472,8 @@
         const context = readOptionValue(args, '--context');
         const hasTestCommandFlag = args.includes('--test');
         const testCommand = readVariadicOptionValue(args, '--test');
+        const hasTestBeforeFlag = args.includes('--test-before');
+        const testBefore = parseTestBeforeOption(readOptionValue(args, '--test-before'), hasTestBeforeFlag);
         const preserveLogs = args.includes('--preserve-logs');
         const isIsolated = args.includes('--isolate');
         const noUi = args.includes('--no-ui');
@@ -73932,6 +74546,7 @@
             model,
             context,
             testCommand,
+            testBefore,
             thinkingLevel,
             priority: minimumPriority !== null && minimumPriority !== void 0 ? minimumPriority : 0,
             minimumPriority,
@@ -73940,6 +74555,21 @@
             limit,
         };
     }
+    /**
+     * Parses and validates the optional pre-coding verification mode.
+     */
+    function parseTestBeforeOption(value, hasTestBeforeFlag) {
+        if (value === undefined) {
+            if (hasTestBeforeFlag) {
+                exitWithUsageError(`Missing value for --test-before. Use one of: ${TEST_BEFORE_MODE_VALUES.join(', ')}.`);
+            }
+            return 'no';
+        }
+        if (!isTestBeforeMode(value)) {
+            exitWithUsageError(`Invalid value for --test-before: "${value}". Use one of: ${TEST_BEFORE_MODE_VALUES.join(', ')}.`);
+        }
+        return value;
+    }
     /**
      * Reads a duration-typed CLI flag, applying the provided default when the flag is absent.
      */
@@ -75698,6 +76328,14 @@
             .filter((statement) => statement !== '');
     }
 
+    /**
+     * Loads the PostgreSQL client (`pg`) on demand
+     *
+     * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast
+     *
+     * @private function of runAutoMigrateTestingServers
+     */
+    const loadPostgresModule = createLazyModuleLoader(() => import('pg'));
     /**
      * Migration targets for testing servers that should be migrated by coding-script auto-migration.
      */
@@ -75775,7 +76413,8 @@
      * @returns Pending migration files grouped by prefix.
      */
     async function listPendingMigrationsByPrefix(options) {
-        const client = new pg.Client({
+        const { Client } = await loadPostgresModule();
+        const client = new Client({
             connectionString: options.connectionString,
             ssl: { rejectUnauthorized: false },
         });
@@ -75932,15 +76571,6 @@
         return lines.join(file.eol);
     }
 
-    /**
-     * Builds a normalized temporary shell script path for prompt runners.
-     */
-    function buildTemporaryPromptScriptPath(options) {
-        const sourceFileName = path.basename(options.sourceFileName);
-        const scriptFileName = `${sourceFileName.replace(/\.[^.]+$/u, '')}${options.suffix || ''}.sh`;
-        return resolvePromptbookTemporaryPath(options.projectPath, options.scriptDirectoryName, scriptFileName);
-    }
-
     /**
      * Builds the suffix which disambiguates one prompt section inside its prompt file.
      *
@@ -75967,32 +76597,6 @@
         });
     }
 
-    /**
-     * Formats usage price for display in prompt status lines and task details.
-     * Examples:
-     * - "$0.12" (certain)
-     * - "~$3.05" (uncertain)
-     * - "$0.00" (zero cost)
-     * - "<$0.01" (tiny non-zero cost)
-     *
-     * @private internal utility of the prompt runners and the Agents Server task details
-     */
-    function formatUsagePrice(usage) {
-        const price = usage.price.value;
-        const isUncertain = usage.price.isUncertain === true;
-        const prefix = isUncertain ? '~' : '';
-        if (price === 0) {
-            return `${prefix}$0.00`;
-        }
-        if (price < 0.01) {
-            return `${prefix}<$0.01`;
-        }
-        if (price < 1) {
-            return `${prefix}$${price.toFixed(4)}`;
-        }
-        return `${prefix}$${price.toFixed(2)}`;
-    }
-
     /**
      * Human-readable labels for each coder run step kind shown in prompt status lines.
      */
@@ -76038,20 +76642,13 @@
     }
 
     /**
-     * Formats runner details for prompt status lines.
+     * Replaces the complete todo status line while preserving its indentation.
+     *
+     * The complete line is replaced because a todo status can contain a required
+     * model/harness token in addition to priority markers.
      */
-    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}\`` : '';
-        if (!normalizedRunner && !normalizedModel) {
-            return 'unknown';
-        }
-        const runnerLabel = normalizedRunner || 'unknown';
-        if (!normalizedModel) {
-            return `${runnerLabel}${thinkingLevelSuffix}`;
-        }
-        return `${runnerLabel} \`${normalizedModel}\`${thinkingLevelSuffix}`;
+    function replacePromptTodoStatusLine(line, replacementStatusLine) {
+        return line.replace(/^(?<indentation>\s*)\[\s*\].*$/u, `$<indentation>${replacementStatusLine}`);
     }
 
     /**
@@ -76071,8 +76668,8 @@
         const loginMethodSuffix = loginMethodLabel ? ` (${loginMethodLabel})` : '';
         const stepsSummary = formatCoderRunSteps(steps);
         const stepsSuffix = stepsSummary === '' ? '' : ` - ${stepsSummary}`;
-        // Replace "[ ]" or "[ ] !!..." with "[x] by runner model thinking level (login method) - Step $price duration; ..."
-        file.lines[section.statusLineIndex] = line.replace(/\[\s*\]\s*!*\s*$/, `[x] ${attemptMetadata}by ${runnerSignature}${loginMethodSuffix}${stepsSuffix}`);
+        // Replace the complete todo status, including any required model/harness token.
+        file.lines[section.statusLineIndex] = replacePromptTodoStatusLine(line, `[x] ${attemptMetadata}by ${runnerSignature}${loginMethodSuffix}${stepsSuffix}`);
     }
 
     /**
@@ -76090,8 +76687,10 @@
         const attemptMetadata = formatPromptAttemptMetadata('failed', attemptCount);
         const duration = moment__default["default"]().diff(promptExecutionStartedDate);
         const durationString = moment__default["default"].duration(duration).humanize();
-        const failureDetails = attemptMetadata === '' ? `failed after ${durationString} by ${runnerSignature}` : `${attemptMetadata}${durationString} by ${runnerSignature}`;
-        file.lines[section.statusLineIndex] = line.replace(/\[\s*\]\s*!*\s*$/, `[!] ${failureDetails}`);
+        const failureDetails = attemptMetadata === ''
+            ? `failed after ${durationString} by ${runnerSignature}`
+            : `${attemptMetadata}${durationString} by ${runnerSignature}`;
+        file.lines[section.statusLineIndex] = replacePromptTodoStatusLine(line, `[!] ${failureDetails}`);
     }
 
     /**
@@ -77061,17 +77660,18 @@
     /**
      * Lists todo prompts that are ready to run (no authoring placeholders).
      */
-    function listRunnablePrompts(files, priorityFilter = {}) {
+    function listRunnablePrompts(files, priorityFilter = {}, promptRunnerIdentity) {
         return listTodoPrompts(files).filter((prompt) => !isPromptToBeWritten(prompt.file, prompt.section) &&
-            isPromptInPriorityFilter(prompt.section, priorityFilter));
+            isPromptInPriorityFilter(prompt.section, priorityFilter) &&
+            isPromptCompatibleWithRunner(prompt.file, prompt.section, promptRunnerIdentity));
     }
 
     /**
      * Selects the next runnable prompt based on priority.
      */
-    function findNextTodoPrompt(files, priorityFilter = {}) {
+    function findNextTodoPrompt(files, priorityFilter = {}, promptRunnerIdentity) {
         let nextPrompt;
-        for (const prompt of listRunnablePrompts(files, priorityFilter)) {
+        for (const prompt of listRunnablePrompts(files, priorityFilter, promptRunnerIdentity)) {
             if (!nextPrompt || prompt.section.priority > nextPrompt.section.priority) {
                 nextPrompt = prompt;
             }
@@ -77082,8 +77682,8 @@
     /**
      * Lists upcoming tasks that are ready to run (no authoring placeholders).
      */
-    function listUpcomingTasks(files, priorityFilter = {}) {
-        return listRunnablePrompts(files, priorityFilter).map(({ file, section }) => ({
+    function listUpcomingTasks(files, priorityFilter = {}, promptRunnerIdentity) {
+        return listRunnablePrompts(files, priorityFilter, promptRunnerIdentity).map(({ file, section }) => ({
             label: buildPromptLabelForDisplay(file, section),
             summary: buildPromptSummary(file, section),
             priority: section.priority,
@@ -77227,6 +77827,71 @@
         }
     }
 
+    /**
+     * Creates the one queue prompt used to repair a pre-existing test failure.
+     */
+    async function createTestBeforeRepairPrompt(options) {
+        const description = spaceTrim((block) => `
+            Fix the existing test failures before implementing any queued coding tasks.
+
+            The verification command \`${options.testCommand}\` failed before coding started. Fix the underlying failure without weakening or removing the tests, and leave the project ready for the remaining coding prompts.
+
+            ## Verification output
+
+            \`\`\`
+            ${block(limitTestOutput(options.testOutput))}
+            \`\`\`
+        `);
+        const createdPrompt = await addCoderPrompt({
+            projectPath: options.projectPath,
+            description,
+            priority: 0,
+        });
+        const promptPath = path.join(options.projectPath, createdPrompt.filePath);
+        const promptFile = parsePromptFile(promptPath, await promises.readFile(promptPath, 'utf-8'));
+        const section = promptFile.sections[0];
+        if (!section) {
+            throw new UnexpectedError(spaceTrim(`
+                The pre-coding test repair prompt was created at \`${createdPrompt.filePath}\` without a runnable section.
+            `));
+        }
+        return { file: promptFile, section };
+    }
+
+    /**
+     * Runs the configured verification command before the first coding prompt.
+     */
+    async function runTestBefore(options) {
+        var _a, _b;
+        const runPromptTestCommandExecutor = (_a = options.runPromptTestCommandExecutor) !== null && _a !== void 0 ? _a : runPromptTestCommand;
+        const initialTestStatusMessage = `Running initial tests before the agent coding starts: ${options.testCommand}`;
+        await ((_b = options.waitForPauseCheckpoint) === null || _b === void 0 ? void 0 : _b.call(options, {
+            checkpointLabel: 'running initial tests before the agent coding starts',
+            phase: 'verifying',
+            statusMessage: initialTestStatusMessage,
+        }));
+        console.info(colors__default["default"].gray(initialTestStatusMessage));
+        try {
+            const testOutput = await runPromptTestCommandExecutor({
+                command: options.testCommand,
+                projectPath: options.projectPath,
+                scriptPath: buildTemporaryPromptScriptPath({
+                    projectPath: options.projectPath,
+                    scriptDirectoryName: 'coder-prompts',
+                    sourceFileName: 'test-before',
+                }),
+            });
+            console.info(colors__default["default"].green('Pre-coding tests passed.'));
+            return { isPassed: true, testOutput };
+        }
+        catch (error) {
+            const testOutput = formatUnknownErrorMessage(error);
+            console.error(colors__default["default"].red('Pre-coding tests failed.'));
+            console.error(testOutput);
+            return { isPassed: false, testOutput };
+        }
+    }
+
     /**
      * Constant for prompts dir.
      */
@@ -77254,6 +77919,10 @@
                 return;
             }
             const { runner, actualRunnerModel, runnerMetadata } = resolvePromptRunner(options);
+            const promptRunnerIdentity = {
+                harnessName: options.agentName,
+                modelName: actualRunnerModel,
+            };
             console.info(colors__default["default"].green(`Running prompts with ${runner.name}`));
             initializeRunUi(uiHandle, runner.name, actualRunnerModel, options);
             await initializeRunUiAgentVisual(uiHandle, resolvedCoderAgent === null || resolvedCoderAgent === void 0 ? void 0 : resolvedCoderAgent.agentSource);
@@ -77268,6 +77937,7 @@
             let previousRoundStartTime;
             let previousRoundEndTime;
             let completedRunCount = 0;
+            let hasRunTestBefore = false;
             while (just(true)) {
                 if (options.autoPull && !options.dryRun) {
                     await waitForRequestedPause({
@@ -77280,6 +77950,35 @@
                     options,
                     isRichUiEnabled,
                 });
+                if (!hasRunTestBefore && options.testBefore !== 'no') {
+                    await waitForRequestedPause({
+                        checkpointLabel: 'loading prompts before running initial tests',
+                        phase: 'loading',
+                        statusMessage: 'Loading prompts before running initial tests...',
+                    });
+                    await loadPromptQueueSnapshot({
+                        options,
+                        isRichUiEnabled,
+                        progressDisplay,
+                        uiHandle,
+                        promptRunnerIdentity,
+                    });
+                }
+                if (!hasRunTestBefore) {
+                    hasWaitedForStart = await runTestBeforeIfNeeded({
+                        options,
+                        runner,
+                        runnerMetadata,
+                        resolvedCoderContext,
+                        resolvedAgentSystemMessage,
+                        isRichUiEnabled,
+                        progressDisplay,
+                        uiHandle,
+                        waitForRequestedPause,
+                        hasWaitedForStart,
+                    });
+                    hasRunTestBefore = true;
+                }
                 await waitForRequestedPause({
                     checkpointLabel: 'loading prompts',
                     phase: 'loading',
@@ -77290,6 +77989,7 @@
                     isRichUiEnabled,
                     progressDisplay,
                     uiHandle,
+                    promptRunnerIdentity,
                 });
                 hasShownUpcomingTasks || (hasShownUpcomingTasks = showUpcomingTasksOnce({
                     hasShownUpcomingTasks,
@@ -77297,6 +77997,7 @@
                     stats: promptQueueSnapshot.stats,
                     priorityFilter: options.priorityFilter,
                     isRichUiEnabled,
+                    promptRunnerIdentity,
                 }));
                 if (!promptQueueSnapshot.nextPrompt) {
                     if (isEndAfterCurrentPromptRequested(completedRunCount)) {
@@ -77399,6 +78100,14 @@
      * Validates cross-flag constraints before the run starts.
      */
     function validateRunCodexPromptOptions(options) {
+        var _a;
+        if (!isTestBeforeMode((_a = options.testBefore) !== null && _a !== void 0 ? _a : 'no')) {
+            throw new NotAllowed(_spaceTrim.spaceTrim(`
+                Invalid ${'`--test-before`'} mode: \`${String(options.testBefore)}\`.
+
+                Use one of: \`no\`, \`yes-and-fail\`, \`yes-and-fix\`.
+            `));
+        }
         if (options.allowDestructiveAutoMigrate && !options.autoMigrate) {
             throw new DatabaseError(_spaceTrim.spaceTrim(`
                 Flag \`--allow-destructive-auto-migrate\` requires \`--auto-migrate\`.
@@ -77469,20 +78178,103 @@
      * Normalizes legacy and current priority options into one validated run option shape.
      */
     function normalizeRunOptions(options) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g;
+        const testBefore = (_a = options.testBefore) !== null && _a !== void 0 ? _a : 'no';
+        const normalizedTestCommand = (_b = options.testCommand) === null || _b === void 0 ? void 0 : _b.trim();
         const priorityFilter = normalizePriorityFilter({
             priority: options.priority,
-            minimumPriority: (_a = options.minimumPriority) !== null && _a !== void 0 ? _a : (_b = options.priorityFilter) === null || _b === void 0 ? void 0 : _b.minimumPriority,
-            maximumPriority: (_c = options.maximumPriority) !== null && _c !== void 0 ? _c : (_d = options.priorityFilter) === null || _d === void 0 ? void 0 : _d.maximumPriority,
+            minimumPriority: (_c = options.minimumPriority) !== null && _c !== void 0 ? _c : (_d = options.priorityFilter) === null || _d === void 0 ? void 0 : _d.minimumPriority,
+            maximumPriority: (_e = options.maximumPriority) !== null && _e !== void 0 ? _e : (_f = options.priorityFilter) === null || _f === void 0 ? void 0 : _f.maximumPriority,
         });
         return {
             ...options,
-            priority: (_e = priorityFilter.minimumPriority) !== null && _e !== void 0 ? _e : 0,
+            testBefore,
+            testCommand: normalizedTestCommand || (testBefore === 'no' ? undefined : DEFAULT_CODER_TEST_COMMAND),
+            priority: (_g = priorityFilter.minimumPriority) !== null && _g !== void 0 ? _g : 0,
             minimumPriority: priorityFilter.minimumPriority,
             maximumPriority: priorityFilter.maximumPriority,
             priorityFilter,
         };
     }
+    /**
+     * Runs the optional pre-coding verification and, when requested, its one repair prompt.
+     */
+    async function runTestBeforeIfNeeded(options) {
+        const { options: runOptions, runner, runnerMetadata, resolvedCoderContext, resolvedAgentSystemMessage, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, hasWaitedForStart, } = options;
+        if (runOptions.testBefore === 'no') {
+            return hasWaitedForStart;
+        }
+        if (!runOptions.testCommand) {
+            throw new NotAllowed(_spaceTrim.spaceTrim(`
+                ${'`--test-before ' + runOptions.testBefore + '`'} requires a verification command.
+
+                Pass one with ${'`--test <test-command>`'} or use the default ${'`npm test`'} command by providing the mode through the CLI.
+            `));
+        }
+        if (!runOptions.ignoreGitChanges) {
+            await waitForRequestedPause({
+                checkpointLabel: 'checking the git working tree before testing',
+                phase: 'loading',
+                statusMessage: 'Checking the working tree before testing...',
+            });
+            await ensureWorkingTreeClean();
+        }
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.startCapturingAgentOutput();
+        const testBeforeResult = await runTestBefore({
+            testCommand: runOptions.testCommand,
+            projectPath: process.cwd(),
+            waitForPauseCheckpoint: waitForRequestedPause,
+        }).finally(() => {
+            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.stopCapturingAgentOutput();
+        });
+        if (testBeforeResult.isPassed) {
+            return hasWaitedForStart;
+        }
+        const testOutput = limitTestOutput(testBeforeResult.testOutput);
+        if (runOptions.testBefore === 'yes-and-fail') {
+            throw new NotAllowed(_spaceTrim.spaceTrim((block) => `
+                    Pre-coding verification command \`${runOptions.testCommand}\` failed.
+
+                    The coding agent was not started because the project was already failing before the first queued prompt.
+
+                    ### Test results
+                    ${'```'}
+                    ${block(testOutput)}
+                    ${'```'}
+                `));
+        }
+        const repairPrompt = await createTestBeforeRepairPrompt({
+            projectPath: process.cwd(),
+            testCommand: runOptions.testCommand,
+            testOutput,
+        });
+        const repairPromptLabel = buildPromptLabelForDisplay(repairPrompt.file, repairPrompt.section);
+        const updatedHasWaitedForStart = await waitForPromptConfirmationIfNeeded({
+            options: runOptions,
+            nextPrompt: repairPrompt,
+            promptLabel: repairPromptLabel,
+            hasWaitedForStart,
+            isRichUiEnabled,
+            progressDisplay,
+            uiHandle,
+        });
+        // The repair prompt is created in the current worktree so it can be recorded and committed with the repair.
+        // It therefore intentionally uses the regular round here even when the queue itself uses --isolate.
+        await runPromptRound({
+            options: runOptions,
+            runner,
+            runnerMetadata,
+            nextPrompt: repairPrompt,
+            promptLabel: repairPromptLabel,
+            resolvedCoderContext,
+            resolvedAgentSystemMessage,
+            isRichUiEnabled,
+            progressDisplay,
+            uiHandle,
+            waitForRequestedPause,
+        });
+        return updatedHasWaitedForStart;
+    }
     /**
      * Creates a pause waiter that keeps the progress display and rich UI in sync.
      */
@@ -77567,7 +78359,7 @@
      * Loads prompt files, updates progress displays, and selects the next runnable prompt.
      */
     async function loadPromptQueueSnapshot(options) {
-        const { options: runOptions, isRichUiEnabled, progressDisplay, uiHandle } = options;
+        const { options: runOptions, isRichUiEnabled, progressDisplay, uiHandle, promptRunnerIdentity } = options;
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentScriptPath(undefined);
         const promptFiles = await loadPromptFiles(PROMPTS_DIR$1);
         const stats = summarizePrompts(promptFiles, runOptions.priorityFilter);
@@ -77579,14 +78371,14 @@
         return {
             promptFiles,
             stats,
-            nextPrompt: findNextTodoPrompt(promptFiles, runOptions.priorityFilter),
+            nextPrompt: findNextTodoPrompt(promptFiles, runOptions.priorityFilter, promptRunnerIdentity),
         };
     }
     /**
      * Prints upcoming tasks only on the first loop iteration in plain-console mode.
      */
     function showUpcomingTasksOnce(options) {
-        const { hasShownUpcomingTasks, promptFiles, stats, priorityFilter, isRichUiEnabled } = options;
+        const { hasShownUpcomingTasks, promptFiles, stats, priorityFilter, isRichUiEnabled, promptRunnerIdentity } = options;
         if (hasShownUpcomingTasks || isRichUiEnabled) {
             return true;
         }
@@ -77595,7 +78387,7 @@
             printPromptsToBeWritten(promptFiles, priorityFilter);
             console.info('');
         }
-        printUpcomingTasks(listUpcomingTasks(promptFiles, priorityFilter));
+        printUpcomingTasks(listUpcomingTasks(promptFiles, priorityFilter, promptRunnerIdentity));
         return true;
     }
     /**
@@ -77605,7 +78397,10 @@
         if (promptQueueSnapshot.nextPrompt) {
             return false;
         }
-        if (promptQueueSnapshot.stats.toBeWritten > 0) {
+        if (promptQueueSnapshot.stats.forAgent > 0) {
+            announceRunCompletion('No prompts match the selected harness or model.', colors__default["default"].yellow, isRichUiEnabled, uiHandle);
+        }
+        else if (promptQueueSnapshot.stats.toBeWritten > 0) {
             announceRunCompletion('No prompts ready for agent.', colors__default["default"].yellow, isRichUiEnabled, uiHandle);
         }
         else {
@@ -77646,9 +78441,16 @@
      * Updates the UI status message while waiting for new prompts in keepAlive server mode.
      */
     function announceKeepAliveStatus(promptQueueSnapshot, isRichUiEnabled, uiHandle) {
-        const message = promptQueueSnapshot.stats.toBeWritten > 0
-            ? 'No prompts ready for agent. Watching for changes...'
-            : 'All prompts are done. Watching for changes...';
+        let message;
+        if (promptQueueSnapshot.stats.forAgent > 0) {
+            message = 'No prompts match the selected harness or model. Watching for changes...';
+        }
+        else if (promptQueueSnapshot.stats.toBeWritten > 0) {
+            message = 'No prompts ready for agent. Watching for changes...';
+        }
+        else {
+            message = 'All prompts are done. Watching for changes...';
+        }
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(message);
         uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('waiting');
         if (!isRichUiEnabled) {
@@ -77670,7 +78472,7 @@
      * Waits for the optional user confirmation before starting the selected prompt.
      */
     async function waitForPromptConfirmationIfNeeded(options) {
-        const { options: runOptions, nextPrompt, promptLabel, hasWaitedForStart, isRichUiEnabled, progressDisplay, uiHandle } = options;
+        const { options: runOptions, nextPrompt, promptLabel, hasWaitedForStart, isRichUiEnabled, progressDisplay, uiHandle, } = options;
         if (!runOptions.waitForUser) {
             return hasWaitedForStart;
         }
@@ -78992,14 +79794,21 @@
         let promptFiles = initialFiles;
         const skippedFiles = new Set();
         while (true) {
+            // Note: The git synchronization is applied around each single verification, not once per whole run
+            await $pullCoderChanges({ gitSync: normalizedOptions.gitSync });
+            if (normalizedOptions.gitSync.isAutoPullEnabled) {
+                // Note: The pull can bring in prompt file changes, so the queue is reloaded before it is used
+                promptFiles = (await loadPromptFilesForVerification(normalizedOptions)).promptFiles;
+            }
             displayPromptOverview(promptFiles);
             // First priority: verify files where all prompts are marked as done
             const fileWithAllDone = findFileWithAllDonePrompts(promptFiles, skippedFiles);
             if (fileWithAllDone) {
-                const wasSkipped = await verifyDonePromptsInFile(fileWithAllDone);
-                if (wasSkipped) {
+                const outcome = await verifyDonePromptsInFile(fileWithAllDone);
+                if (outcome.wasSkipped) {
                     skippedFiles.add(fileWithAllDone.path);
                 }
+                await $commitVerificationOutcome(normalizedOptions.gitSync, outcome);
                 promptFiles = (await loadPromptFilesForVerification(normalizedOptions)).promptFiles;
                 continue;
             }
@@ -79009,10 +79818,20 @@
                 console.info(colors__default["default"].green('\n✅ All prompts have been verified.'));
                 break;
             }
-            await resolvePrompt(nextPrompt);
+            const outcome = await resolvePrompt(nextPrompt);
+            await $commitVerificationOutcome(normalizedOptions.gitSync, outcome);
             promptFiles = (await loadPromptFilesForVerification(normalizedOptions)).promptFiles;
         }
     }
+    /**
+     * Commits and pushes one applied verification when the git synchronization is enabled.
+     */
+    async function $commitVerificationOutcome(gitSync, outcome) {
+        if (outcome.commitMessage === null) {
+            return;
+        }
+        await $commitCoderChanges({ gitSync, commitMessage: outcome.commitMessage });
+    }
     /**
      * Parses supported command-line arguments for the standalone verification script.
      */
@@ -79020,6 +79839,11 @@
         return {
             reverse: args.includes('--reverse'),
             ignore: readRepeatableStringOption(args, '--ignore'),
+            gitSync: {
+                isCommitEnabled: args.includes('--commit'),
+                isAutoPushEnabled: args.includes('--auto-push'),
+                isAutoPullEnabled: args.includes('--auto-pull'),
+            },
         };
     }
     /**
@@ -79071,10 +79895,11 @@
      * Normalizes verification options so the rest of the flow can assume stable defaults.
      */
     function normalizeVerifyPromptsOptions(options) {
-        var _a, _b;
+        var _a, _b, _c;
         return {
             reverse: (_a = options.reverse) !== null && _a !== void 0 ? _a : false,
             ignore: normalizeIgnoreValues((_b = options.ignore) !== null && _b !== void 0 ? _b : []),
+            gitSync: (_c = options.gitSync) !== null && _c !== void 0 ? _c : DISABLED_CODER_GIT_SYNC_OPTIONS,
         };
     }
     /**
@@ -79205,7 +80030,6 @@
     /**
      * Verifies the last done [x] prompt in a file and decides whether to archive it or add a repair prompt.
      * Ignores not-ready prompts like [-], [.], [?], etc.
-     * Returns true if the file was skipped, false otherwise.
      */
     async function verifyDonePromptsInFile(file) {
         const doneCount = file.sections.filter((s) => s.status === 'done').length;
@@ -79225,32 +80049,45 @@
         }
         if (!lastDoneSection) {
             console.info(colors__default["default"].gray('No done [x] prompts found in this file.'));
-            return false;
+            return { wasSkipped: false, commitMessage: null };
         }
         console.info(colors__default["default"].gray('Verifying the last [x] prompt in the file...\n'));
         displayPromptSnippet({ file, section: lastDoneSection });
         const decision = await promptForDoneVerification(file, lastDoneSection);
         if (decision === 'done') {
             await archivePromptFile(file);
-            return false;
+            return { wasSkipped: false, commitMessage: buildArchiveCommitMessage(file) };
         }
         else if (decision === 'needs-work') {
             console.info(colors__default["default"].yellow('\n⚠️  This prompt needs repair.'));
             await appendRepairPrompt(file, lastDoneSection);
-            return false;
+            return { wasSkipped: false, commitMessage: buildRepairCommitMessage(file) };
         }
         else {
             console.info(colors__default["default"].gray('\n⏩ Skipped, no changes made.'));
-            return true;
+            return { wasSkipped: true, commitMessage: null };
         }
     }
+    /**
+     * Builds the commit message describing one archived prompt file.
+     */
+    function buildArchiveCommitMessage(file) {
+        return `✅ Prompt done and archived \`${file.name}\``; // <- $commitCoderChanges({
+    }
+    /**
+     * Builds the commit message describing one appended repair prompt.
+     */
+    function buildRepairCommitMessage(file) {
+        return `❌ Repair prompt added into \`${file.name}\``; // <- $commitCoderChanges({
+    }
     /**
      * Asks the user to verify if a done prompt is actually completed.
      * Returns 'done' if verified, 'needs-work' if not done, or 'skip' to skip this file.
      */
     async function promptForDoneVerification(file, section) {
         const promptLabel = buildPromptLabelForDisplay(file, section);
-        const response = await prompts__default["default"]({
+        const { default: prompts } = await loadPromptsModule();
+        const response = await prompts({
             type: 'select',
             name: 'verified',
             message: `Is ${colors__default["default"].bold(promptLabel)} actually done?`,
@@ -79318,17 +80155,18 @@
         const decision = await promptForDecision(selection);
         if (decision === 'done') {
             await archivePromptFile(selection.file);
+            return { wasSkipped: false, commitMessage: buildArchiveCommitMessage(selection.file) };
         }
-        else {
-            await appendRepairPrompt(selection.file, selection.section);
-        }
+        await appendRepairPrompt(selection.file, selection.section);
+        return { wasSkipped: false, commitMessage: buildRepairCommitMessage(selection.file) };
     }
     /**
      * Presents the interactive decision menu for the current prompt section.
      */
     async function promptForDecision(selection) {
         const promptLabel = buildPromptLabelForDisplay(selection.file, selection.section);
-        const response = await prompts__default["default"]({
+        const { default: prompts } = await loadPromptsModule();
+        const response = await prompts({
             type: 'select',
             name: 'decision',
             message: `Is ${colors__default["default"].bold(promptLabel)} resolved?`,