@promptbook/cli 0.114.0-2 → 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('readline'), require('waitasecond'), require('prompts'), 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('os'), require('events'), 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', 'readline', 'waitasecond', 'prompts', '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', 'os', 'events', '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.readline, global.waitasecond, global.prompts, 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.os, global.events, global.mimeTypes, global.papaparse, global.pg, null, global.url));
-})(this, (function (exports, colors, commander, _spaceTrim, promises, path, crypto, child_process, moment, fs, dotenv, readline, waitasecond, prompts, 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, os, events, 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 }; }
 
@@ -31,10 +31,8 @@
     var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
     var dotenv__namespace = /*#__PURE__*/_interopNamespace(dotenv);
     var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
-    var prompts__default = /*#__PURE__*/_interopDefaultLegacy(prompts);
     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-2';
+    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({
@@ -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');
     }
@@ -32942,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 });
@@ -32951,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,
@@ -42291,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.
      *
@@ -42544,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(`
@@ -42562,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`,
+            });
         }));
     }
     /**
@@ -42644,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',
@@ -43064,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.
@@ -43075,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);
         }));
     }
@@ -44058,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);
         }));
     }
@@ -44085,62 +44230,44 @@
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
     /**
-     * Initializes `coder ping` command for Promptbook CLI utilities.
-     *
-     * The command makes one small, isolated harness/model call, prints its result
-     * and reports how long the harness/model turn took.
+     * 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.
+     * 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(`
-            Test one harness and model connection with a small disposable task
+            Send one tiny dummy prompt to a harness and model to measure and warm them up
 
             ${PROMPT_RUNNER_DESCRIPTION}
 
             Features:
-            - Runs the dummy task in a temporary directory outside the current project
-            - Prints the result returned by the selected harness and model
-            - Reports the elapsed harness/model response time in milliseconds
-            - Can be used to start consuming an applicable harness/model quota before a longer run
+            - 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 normalizedOptions = normalizePromptRunnerSelectionCliOptions(cliOptions, { isAgentRequired: true });
-            const agentName = normalizedOptions.agentName;
-            if (!agentName) {
-                throw new NotAllowed(_spaceTrim.spaceTrim(`
-                        A harness is required for \`ptbk coder ping\`.
-
-                        Pass one with \`--harness <harness-name>\`.
-                    `));
-            }
-            await $ensureHarnessInstallations([agentName]);
-            // Note: Import the runner-backed implementation dynamically to avoid loading heavy dependencies until needed.
-            const { runCoderPing } = await Promise.resolve().then(function () { return runCoderPing$1; });
-            const pingResult = await runCoderPing({
-                agentName,
-                model: normalizedOptions.model,
-                thinkingLevel: normalizedOptions.thinkingLevel,
-                isUiDisabled: normalizedOptions.noUi,
-                isCreditsAllowed: normalizedOptions.allowCredits,
+            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(pingResult);
+            printCoderPingResult(result);
         }));
     }
-    /**
-     * Prints the result and duration of one completed coder ping.
-     */
-    function printCoderPingResult(pingResult) {
-        console.info(_spaceTrim.spaceTrim(`
-            Result: ${pingResult.result}
-            Time: ${pingResult.elapsedTimeMs.toFixed(0)} ms
-        `));
-    }
     // 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
 
@@ -44511,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);
@@ -44557,8 +44690,8 @@
      * - add: Add one ready-to-run prompt file to the queue
      * - generate-boilerplates: Generate prompt boilerplate files
      * - find-refactor-candidates: Find files that need refactoring
-     * - ping: Test one harness and model connection with a disposable task
      * - 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
      *
@@ -44577,8 +44710,8 @@
             - generate-boilerplates: Generate prompt boilerplate files
             - find-refactor-candidates: Find files that need refactoring
             - find-unwritten: List prompt sections that still need to be authored
-            - ping: Test one harness and model connection with a disposable task
             - 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
@@ -44589,8 +44722,8 @@
         $initializeCoderGenerateBoilerplatesCommand(coderCommand);
         $initializeCoderFindRefactorCandidatesCommand(coderCommand);
         $initializeCoderFindUnwrittenCommand(coderCommand);
-        $initializeCoderPingCommand(coderCommand);
         $initializeCoderRunCommand(coderCommand);
+        $initializeCoderPingCommand(coderCommand);
         $initializeCoderServerCommand(coderCommand);
         $initializeCoderVerifyCommand(coderCommand);
         $initializeCoderFindFreshEmojiTagCommand(coderCommand);
@@ -45424,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.
      *
@@ -45452,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',
@@ -46119,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',
@@ -46494,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
      *
@@ -46508,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`);
@@ -50571,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
      *
@@ -50607,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');
@@ -50647,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 };
         }
         /**
@@ -54210,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 });
@@ -54838,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',
@@ -55145,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: '',
@@ -55232,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)
@@ -58137,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.
      *
@@ -58174,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;
         }
@@ -58437,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.
      *
@@ -58470,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;
         }
@@ -60279,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.
      *
@@ -60305,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;
         }
@@ -68018,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',
@@ -69231,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.
      */
@@ -69284,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;
@@ -69296,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),
@@ -69507,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,
@@ -69721,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.',
@@ -69767,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: {
@@ -69909,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);
             }
         }
         /**
@@ -72241,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.
      */
@@ -72715,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.
      *
@@ -72740,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}`);
@@ -72799,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),
@@ -72812,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;
                     }
                 }
@@ -72844,6 +73149,7 @@
      * @private function of analyzeSourceFileForRefactorCandidate
      */
     function summarizeFunctionsInSourceFile(sourceFile) {
+        const ts = getLoadedTypescriptModule();
         let functionCount = 0;
         let maxFunctionComplexity = 0;
         let mostComplexFunctionName = null;
@@ -72856,7 +73162,7 @@
                     mostComplexFunctionName = getFunctionDisplayName(node);
                 }
             }
-            ts__namespace.forEachChild(node, visitNode);
+            ts.forEachChild(node, visitNode);
         };
         visitNode(sourceFile);
         return {
@@ -72871,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;
@@ -72889,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.
@@ -72901,6 +73209,7 @@
         if (!functionNode.body) {
             return 1;
         }
+        const ts = getLoadedTypescriptModule();
         let complexity = 1;
         const visitNode = (node) => {
             if (node !== functionNode.body && isCountedFunctionLikeDeclaration(node)) {
@@ -72909,7 +73218,7 @@
             if (isComplexityDecisionNode(node)) {
                 complexity += 1;
             }
-            ts__namespace.forEachChild(node, visitNode);
+            ts.forEachChild(node, visitNode);
         };
         visitNode(functionNode.body);
         return complexity;
@@ -72920,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;
     }
@@ -72945,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);
             }
         }
@@ -72977,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.
@@ -72985,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();
@@ -73007,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.
@@ -73866,63 +74180,240 @@
     });
 
     /**
-     * Agent source used by `ptbk coder ping` for its disposable connectivity turn.
+     * Builds a normalized temporary shell script path for prompt runners.
      */
-    const PING_AGENT_SOURCE = _spaceTrim.spaceTrim(`
-    Promptbook Coder Ping Agent
+    function buildTemporaryPromptScriptPath(options) {
+        const sourceFileName = path.basename(options.sourceFileName);
+        const scriptFileName = `${sourceFileName.replace(/\.[^.]+$/u, '')}${options.suffix || ''}.sh`;
+        return resolvePromptbookTemporaryPath(options.projectPath, options.scriptDirectoryName, scriptFileName);
+    }
 
-    PERSONA You are a connectivity test agent. Perform only the tiny task requested by the user and answer concisely.
-`);
     /**
-     * User message used by `ptbk coder ping` to produce a deterministic response.
+     * 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 PING_MESSAGE = 'Reply with exactly the single word PONG and nothing else.';
+    const CODER_PING_EXPECTED_ANSWER = String(CODER_PING_FIRST_FACTOR * CODER_PING_SECOND_FACTOR);
     /**
-     * Runs one small harness/model turn in a disposable temporary project.
+     * Builds the dummy prompt sent by `ptbk coder ping`.
      *
-     * The temporary project is outside the caller's repository, so even a harness
-     * that writes files cannot change the project from which `ptbk coder ping` was
-     * started.
+     * 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.
      */
-    async function runCoderPing(options) {
-        const temporaryProjectPath = await promises.mkdtemp(path.join(os.tmpdir(), 'promptbook-coder-ping-'));
-        const originalWorkingDirectory = process.cwd();
-        try {
-            const agentPath = path.join(temporaryProjectPath, 'ping.book');
-            await promises.writeFile(agentPath, `${PING_AGENT_SOURCE}\n`, 'utf-8');
-            // Note: Some supported CLI wrappers inherit the Node process working directory instead of using projectPath.
-            process.chdir(temporaryProjectPath);
-            const startedAt = performance.now();
-            const result = await executeAgentChatTurn({
-                agentPath,
-                currentWorkingDirectory: temporaryProjectPath,
-                agentName: options.agentName,
-                model: options.model,
-                isVerbose: false,
-                noUi: options.isUiDisabled,
-                thinkingLevel: options.thinkingLevel,
-                allowCredits: options.isCreditsAllowed,
-                messages: [
-                    {
-                        sender: 'USER',
-                        content: PING_MESSAGE,
-                    },
-                ],
+    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: result.answer,
-                elapsedTimeMs: performance.now() - startedAt,
-            };
+            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`;
         }
-        finally {
-            process.chdir(originalWorkingDirectory);
-            await promises.rm(temporaryProjectPath, { recursive: true, force: true });
+        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}`;
     }
 
-    var runCoderPing$1 = /*#__PURE__*/Object.freeze({
+    /**
+     * 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,
-        runCoderPing: runCoderPing
+        printCoderPingResult: printCoderPingResult
     });
 
     /**
@@ -75837,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.
      */
@@ -75914,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 },
         });
@@ -76071,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.
      *
@@ -76106,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.
      */
@@ -76176,23 +76641,6 @@
         return `(failed after ${attemptCount} attempts) `;
     }
 
-    /**
-     * 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}`;
-    }
-
     /**
      * Replaces the complete todo status line while preserving its indentation.
      *
@@ -79346,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;
             }
@@ -79363,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.
      */
@@ -79374,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'),
+            },
         };
     }
     /**
@@ -79425,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,
         };
     }
     /**
@@ -79559,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;
@@ -79579,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?`,
@@ -79672,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?`,