@promptbook/cli 0.114.0-2 → 0.114.0-3

package/esm/index.es.js

@@ -1,7 +1,7 @@
 import colors from 'colors';
 import commander, { Option } from 'commander';
 import _spaceTrim, { spaceTrim as spaceTrim$1 } from 'spacetrim';
-import { writeFile, stat, mkdir, readFile, readdir, rm, cp, lstat, symlink, rename, unlink, appendFile, realpath, copyFile, access, constants, watch, rmdir, mkdtemp } from 'fs/promises';
+import { writeFile, stat, mkdir, readFile, readdir, rm, cp, lstat, symlink, rename, unlink, appendFile, realpath, copyFile, access, constants, watch, rmdir } from 'fs/promises';
 import { join, delimiter, relative, basename, resolve, dirname, isAbsolute, extname } from 'path';
 import { createHash, randomBytes } from 'crypto';
 import { spawn } from 'child_process';
@@ -12,13 +12,8 @@ import * as dotenv from 'dotenv';
 import * as readline from 'readline';
 import { emitKeypressEvents, clearLine, cursorTo, createInterface } from 'readline';
 import { forTime, forEver } from 'waitasecond';
-import prompts from 'prompts';
 import hexEncoder from 'crypto-js/enc-hex';
 import sha256 from 'crypto-js/sha256';
-import { io } from 'socket.io-client';
-import JSZip from 'jszip';
-import { Readability } from '@mozilla/readability';
-import { JSDOM } from 'jsdom';
 import CryptoJS from 'crypto-js';
 import showdown from 'showdown';
 import glob from 'glob-promise';
@@ -29,19 +24,13 @@ import * as OpenApiValidator from 'express-openapi-validator';
 import swaggerUi from 'swagger-ui-express';
 import { createElement } from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
-import Anthropic from '@anthropic-ai/sdk';
 import Bottleneck from 'bottleneck';
-import { OpenAIClient, AzureKeyCredential } from '@azure/openai';
 import { Subject, BehaviorSubject } from 'rxjs';
-import { fileSearchTool, tool, Agent as Agent$1, webSearchTool, run, setDefaultOpenAIClient, setDefaultOpenAIKey } from '@openai/agents';
-import OpenAI from 'openai';
-import * as ts from 'typescript';
 import ignore from 'ignore';
-import { tmpdir } from 'os';
 import { EventEmitter } from 'events';
+import { tmpdir } from 'os';
 import { lookup, extension } from 'mime-types';
 import papaparse from 'papaparse';
-import { Client } from 'pg';
 import '@supabase/supabase-js';
 import { pathToFileURL } from 'url';
 
@@ -59,7 +48,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -3293,6 +3282,12 @@ const PTBK_AGENTS_SERVER_BUILD_WORKER_COUNT_ENV = 'PTBK_AGENTS_SERVER_BUILD_WORK
  * @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.
  *
@@ -3317,6 +3312,11 @@ function createAgentsServerRuntimeEnvironment(environment, nodeModulesPath, opti
                 [PTBK_AGENTS_SERVER_IGNORE_NEXT_VALIDATION_ENV]: 'true',
             }
             : {}),
+        ...(options.isWebpackFilesystemCacheDisabled
+            ? {
+                [PTBK_AGENTS_SERVER_DISABLE_WEBPACK_FILESYSTEM_CACHE_ENV]: 'true',
+            }
+            : {}),
     };
 }
 /**
@@ -4050,6 +4050,7 @@ async function ensureAgentsServerBuild(options = {}) {
     });
     const buildEnvironment = createAgentsServerRuntimeEnvironment(environment, preparedRuntime.nodeModulesPath, {
         isNextValidationIgnored: preparedRuntime.isAppPathMaterialized,
+        isWebpackFilesystemCacheDisabled: true,
     });
     if (!options.isBuildForced &&
         (await isAgentsServerBuildCacheCurrent({
@@ -28226,6 +28227,13 @@ function toPosixPath(filePath) {
  * 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.
  */
@@ -28261,7 +28269,7 @@ async function appendScriptExecutionLogStart({ scriptPath, scriptContent, logPat
             --- raw input ---
             ${block(normalizedInput)}
 
-            --- raw output ---
+            ${SCRIPT_EXECUTION_LOG_RAW_OUTPUT_MARKER}
         `);
     await appendFile(logPath, `${logSection}\n`, 'utf-8');
 }
@@ -32938,8 +32946,12 @@ function readOptionalSigningKeyValue() {
  * `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 mkdir(dirname(commitMessagePath), { recursive: true });
@@ -32947,7 +32959,10 @@ async function commitChanges(message, options) {
     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,
@@ -42287,6 +42302,91 @@ function $initializeAgentsServerCommand(program) {
 // 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$1(`
+    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$1(`
+                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.
  *
@@ -42540,15 +42640,17 @@ const FALLBACK_PROMPT_SLUG = 'prompt';
  */
 function $initializeCoderAddCommand(program) {
     const command = program.command('add');
-    command.description(spaceTrim$1(`
-            Add one ready-to-run prompt file to the queue
+    command.description(spaceTrim$1((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$1(`
@@ -42558,15 +42660,26 @@ function $initializeCoderAddCommand(program) {
         .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`,
+        });
     }));
 }
 /**
@@ -42640,6 +42753,7 @@ async function resolveCoderPromptDescription(descriptionArgument) {
         }
         return standardInputDescription;
     }
+    const { default: prompts } = await loadPromptsModule();
     const response = await prompts({
         type: 'text',
         name: 'description',
@@ -43060,9 +43174,11 @@ function parseIntOption(value) {
  */
 function $initializeCoderGenerateBoilerplatesCommand(program) {
     const command = program.command('generate-boilerplates');
-    command.description(spaceTrim$1(`
-            Generate prompt boilerplate files with unique emoji tags
-        `));
+    command.description(spaceTrim$1((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$1(`
             Prompt template to use.
@@ -43071,14 +43187,25 @@ function $initializeCoderGenerateBoilerplatesCommand(program) {
         .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);
     }));
 }
@@ -44054,12 +44181,24 @@ function $initializeCoderInitCommand(program) {
 
                 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);
     }));
 }
@@ -44081,62 +44220,44 @@ function listDefaultCoderProjectPromptTemplateDisplayPaths() {
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
 /**
- * Initializes `coder ping` command for Promptbook CLI utilities.
+ * 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.
- *
- * 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$1(`
-            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$1(`
-                        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$1(`
-            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
 
@@ -44507,25 +44628,31 @@ function normalizeCommandOptionValue(value) {
  */
 function $initializeCoderVerifyCommand(program) {
     const command = program.command('verify');
-    command.description(spaceTrim$1(`
-            Interactive verification helper for completed prompts
+    command.description(spaceTrim$1((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.bgRed('Prompt verification failed:'), error);
@@ -44553,8 +44680,8 @@ function collectStringOption(value, previousValues) {
  * - 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
  *
@@ -44573,8 +44700,8 @@ function $initializeCoderCommand(program) {
             - 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
@@ -44585,8 +44712,8 @@ function $initializeCoderCommand(program) {
     $initializeCoderGenerateBoilerplatesCommand(coderCommand);
     $initializeCoderFindRefactorCandidatesCommand(coderCommand);
     $initializeCoderFindUnwrittenCommand(coderCommand);
-    $initializeCoderPingCommand(coderCommand);
     $initializeCoderRunCommand(coderCommand);
+    $initializeCoderPingCommand(coderCommand);
     $initializeCoderServerCommand(coderCommand);
     $initializeCoderVerifyCommand(coderCommand);
     $initializeCoderFindFreshEmojiTagCommand(coderCommand);
@@ -45420,6 +45547,14 @@ class FileCacheStorage {
 // 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.
  *
@@ -45448,6 +45583,7 @@ async function createRemoteClient(options) {
 
                     `));
     }
+    const { io } = await loadSocketIoClientModule();
     return new Promise((resolve, reject) => {
         const socket = io(remoteServerUrl, {
             retries: CONNECTION_RETRIES_LIMIT,
@@ -46115,6 +46251,7 @@ async function $provideLlmToolsForCli(options) {
                           You will be logged in to ${remoteServerUrl}
                           If you don't have an account, it will be created automatically.
                       `)));
+                const { default: prompts } = await loadPromptsModule();
                 const { username, password } = await prompts([
                     {
                         type: 'text',
@@ -46490,6 +46627,15 @@ function $initializeLoginCommand(program) {
 // 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
  *
@@ -46504,6 +46650,7 @@ async function loadArchive(filePath, fs) {
         throw new UnexpectedError(`Archive file must have '.bookc' extension`);
     }
     const data = await fs.readFile(filePath);
+    const { default: JSZip } = await loadJsZipModule();
     const archive = await JSZip.loadAsync(data);
     const indexFile = archive.file('index.book.json');
     if (!indexFile) {
@@ -50567,7 +50714,23 @@ function createShowdownConverter() {
     });
 }
 
-// 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
  *
@@ -50603,6 +50766,7 @@ class WebsiteScraper {
         if (this.tools.fs === undefined) {
             throw new EnvironmentMismatchError('Can not scrape websites without filesystem tools');
         }
+        const [{ JSDOM }, { Readability }] = await Promise.all([loadJsdomModule(), loadReadabilityModule()]);
         const jsdom = new JSDOM(await source.asText(), {
             url: source.url,
         });
@@ -54206,6 +54370,7 @@ async function saveArchive(filePath, collectionJson, fs) {
     for (const pipelineJson of collectionJson) {
         validatePipeline(pipelineJson);
     }
+    const { default: JSZip } = await loadJsZipModule();
     const archive = new JSZip();
     const collectionJsonString = stringifyPipelineJson(collectionJson);
     archive.file('index.book.json', collectionJsonString);
@@ -54834,6 +54999,7 @@ async function runInteractiveChatbot(options) {
             else {
                 console.info(colors.gray(`---`));
             }
+            const { default: prompts } = await loadPromptsModule();
             const response = await prompts({
                 type: 'text',
                 name: 'userMessage',
@@ -55141,6 +55307,7 @@ async function resolveRunPipelineSource(pipelineSource) {
     if (pipelineSource) {
         return pipelineSource;
     }
+    const { default: prompts } = await loadPromptsModule();
     const response = await prompts({
         type: 'text',
         name: 'pipelineSource',
@@ -55228,6 +55395,7 @@ async function resolveRunInputParameters(options) {
         console.error(colors.red(createRunMissingInputParametersMessage(pipeline, inputParameters, questions)));
         return process.exit(1);
     }
+    const { default: prompts } = await loadPromptsModule();
     const response = await prompts(questions);
     //                     <- TODO: [🧠][🍼] Change behavior according to the formfactor
     return { ...inputParameters, ...response };
@@ -58133,6 +58301,14 @@ const ANTHROPIC_PROVIDER_PROFILE = {
     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.
  *
@@ -58170,6 +58346,7 @@ class AnthropicClaudeExecutionTools {
             const anthropicOptions = { ...this.options };
             delete anthropicOptions.isVerbose;
             delete anthropicOptions.isProxied;
+            const { Anthropic } = await loadAnthropicClaudeModule();
             this.client = new Anthropic(anthropicOptions);
         }
         return this.client;
@@ -58433,6 +58610,14 @@ const AZURE_OPENAI_PROVIDER_PROFILE = {
     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.
  *
@@ -58466,6 +58651,7 @@ class AzureOpenAiExecutionTools {
     }
     async getClient() {
         if (this.client === null) {
+            const { AzureKeyCredential, OpenAIClient } = await loadAzureOpenAiModule();
             this.client = new OpenAIClient(`https://${this.options.resourceName}.openai.azure.com/`, new AzureKeyCredential(this.options.apiKey));
         }
         return this.client;
@@ -60275,6 +60461,14 @@ class OpenAiCompatibleNonChatPromptCaller {
     }
 }
 
+/**
+ * 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.
  *
@@ -60301,6 +60495,7 @@ class OpenAiCompatibleRequestManager {
                 timeout: API_REQUEST_TIMEOUT,
                 maxRetries: CONNECTION_RETRIES_LIMIT,
             };
+            const { default: OpenAI } = await loadOpenAiModule();
             this.client = new OpenAI(enhancedOptions);
         }
         return this.client;
@@ -68014,6 +68209,7 @@ async function runAgentChat(options) {
     if (options.isVerbose) {
         console.info(colors.gray('Type "exit" or "quit" to end the chat.'));
     }
+    const { default: prompts } = await loadPromptsModule();
     while (true) {
         const response = await prompts({
             type: 'text',
@@ -69227,6 +69423,16 @@ class OpenAiAgentKitExecutionToolsOutputTypeMapper {
     }
 }
 
+/**
+ * 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.
  */
@@ -69280,8 +69486,9 @@ class OpenAiAgentKitExecutionToolsToolBuilder {
     /**
      * 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(fileSearchTool(vectorStoreId));
@@ -69292,11 +69499,11 @@ class OpenAiAgentKitExecutionToolsToolBuilder {
         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(tool({
+            agentKitTools.push(agentKitTool({
                 name: toolDefinition.name,
                 description: toolDefinition.description,
                 parameters: this.normalizeAgentKitToolParameters(toolDefinition.parameters),
@@ -69503,8 +69710,9 @@ class OpenAiAgentKitExecutionToolsToolBuilder {
     /**
      * Creates the native Agent SDK tool used for `USE DEEPSEARCH`.
      */
-    createDeepSearchAgentKitTool(toolDefinition) {
-        const deepSearchAgent = new Agent$1({
+    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),
@@ -69717,8 +69925,9 @@ class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler {
                 vectorStoreId,
             });
         }
-        const agentKitTools = this.buildAgentKitTools({ tools, vectorStoreId });
-        const openAiAgentKitAgent = new Agent$1({
+        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.',
@@ -69763,6 +69972,7 @@ class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler {
             agentName: agentForRun.name,
             input: inputItems,
         };
+        const { run } = await loadOpenAiAgentsModule();
         const streamResult = await run(agentForRun, inputItems, {
             stream: true,
             maxTurns: 200,
@@ -69905,6 +70115,7 @@ class OpenAiAgentKitExecutionTools extends OpenAiVectorStoreHandler {
      * 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();
         setDefaultOpenAIClient(client);
         const apiKey = this.agentKitOptions.apiKey;
@@ -72237,6 +72448,66 @@ var RemoteAgent$1 = /*#__PURE__*/Object.freeze({
     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.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.gray('Nothing to commit, the working tree is clean'));
+        return;
+    }
+    await commitChanges(commitMessage, {
+        projectPath,
+        autoPush: gitSync.isAutoPushEnabled,
+    });
+    console.info(colors.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.
  */
@@ -72711,6 +72982,31 @@ function normalizeRefactorCandidatePath(pathValue) {
 }
 // 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.
  *
@@ -72736,6 +73032,7 @@ async function analyzeSourceFileForRefactorCandidate(options) {
         }
     }
     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}`);
@@ -72795,6 +73092,7 @@ function countLines(content) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function summarizeSourceFileStructure(content, extension, filePath) {
+    const ts = getLoadedTypescriptModule();
     const scriptKind = getScriptKindForExtension(extension);
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, scriptKind);
     return {
@@ -72808,6 +73106,7 @@ function summarizeSourceFileStructure(content, extension, filePath) {
  * @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) {
@@ -72840,6 +73139,7 @@ function countEntitiesInSourceFile(sourceFile) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function summarizeFunctionsInSourceFile(sourceFile) {
+    const ts = getLoadedTypescriptModule();
     let functionCount = 0;
     let maxFunctionComplexity = 0;
     let mostComplexFunctionName = null;
@@ -72867,6 +73167,7 @@ function summarizeFunctionsInSourceFile(sourceFile) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function isCountedFunctionLikeDeclaration(node) {
+    const ts = getLoadedTypescriptModule();
     if (ts.isFunctionDeclaration(node) ||
         ts.isMethodDeclaration(node) ||
         ts.isConstructorDeclaration(node) ||
@@ -72885,6 +73186,7 @@ function isCountedFunctionLikeDeclaration(node) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function isNamedFunctionExpression(node) {
+    const ts = getLoadedTypescriptModule();
     const parent = node.parent;
     return (ts.isVariableDeclaration(parent) || ts.isPropertyDeclaration(parent) || ts.isPropertyAssignment(parent));
 }
@@ -72897,6 +73199,7 @@ function calculateFunctionComplexity(functionNode) {
     if (!functionNode.body) {
         return 1;
     }
+    const ts = getLoadedTypescriptModule();
     let complexity = 1;
     const visitNode = (node) => {
         if (node !== functionNode.body && isCountedFunctionLikeDeclaration(node)) {
@@ -72916,6 +73219,7 @@ function calculateFunctionComplexity(functionNode) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function isComplexityDecisionNode(node) {
+    const ts = getLoadedTypescriptModule();
     if (ts.isIfStatement(node) ||
         ts.isConditionalExpression(node) ||
         ts.isCatchClause(node) ||
@@ -72941,6 +73245,7 @@ function isComplexityDecisionNode(node) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function getFunctionDisplayName(functionNode) {
+    const ts = getLoadedTypescriptModule();
     if (ts.isConstructorDeclaration(functionNode)) {
         return 'constructor';
     }
@@ -72973,6 +73278,7 @@ function getFunctionDisplayName(functionNode) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function getBindingNameText(name) {
+    const ts = getLoadedTypescriptModule();
     return ts.isIdentifier(name) ? name.text : null;
 }
 /**
@@ -72981,6 +73287,7 @@ function getBindingNameText(name) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function getPropertyNameText(name) {
+    const ts = getLoadedTypescriptModule();
     if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
         return name.text;
     }
@@ -73003,6 +73310,7 @@ function buildComplexityReason(structureSummary, maxAllowedFunctionComplexity) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function getScriptKindForExtension(extension) {
+    const ts = getLoadedTypescriptModule();
     if (extension === '.tsx') {
         return ts.ScriptKind.TSX;
     }
@@ -73862,63 +74170,240 @@ var findUnwrittenPrompts$1 = /*#__PURE__*/Object.freeze({
 });
 
 /**
- * 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$1(`
-    Promptbook Coder Ping Agent
+function buildTemporaryPromptScriptPath(options) {
+    const sourceFileName = 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 PING_MESSAGE = 'Reply with exactly the single word PONG and nothing else.';
+const CODER_PING_SECOND_FACTOR = 7;
 /**
- * Runs one small harness/model turn in a disposable temporary project.
+ * 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 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 mkdtemp(join(tmpdir(), 'promptbook-coder-ping-'));
-    const originalWorkingDirectory = process.cwd();
-    try {
-        const agentPath = join(temporaryProjectPath, 'ping.book');
-        await 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 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 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)}`;
 }
 
-var runCoderPing$1 = /*#__PURE__*/Object.freeze({
+/**
+ * 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.green(`🏓 ${runnerSignature}${loginMethodSuffix} answered in ${formatCoderPingResponseTime(result.durationMs)}`));
+    console.info(colors.gray(`   Answer: ${formatCoderPingAnswer(result)}`));
+    console.info(colors.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
 });
 
 /**
@@ -75833,6 +76318,14 @@ function splitSqlStatements(sql) {
         .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.
  */
@@ -75910,6 +76403,7 @@ async function runAutoMigrateTestingServersImmediately(options) {
  * @returns Pending migration files grouped by prefix.
  */
 async function listPendingMigrationsByPrefix(options) {
+    const { Client } = await loadPostgresModule();
     const client = new Client({
         connectionString: options.connectionString,
         ssl: { rejectUnauthorized: false },
@@ -76067,15 +76561,6 @@ function buildCommitMessage(file, section) {
     return lines.join(file.eol);
 }
 
-/**
- * Builds a normalized temporary shell script path for prompt runners.
- */
-function buildTemporaryPromptScriptPath(options) {
-    const sourceFileName = 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.
  *
@@ -76102,32 +76587,6 @@ function buildScriptPath(file, section, projectPath = process.cwd()) {
     });
 }
 
-/**
- * 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.
  */
@@ -76172,23 +76631,6 @@ function formatPromptAttemptMetadata(status, attemptCount) {
     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.
  *
@@ -79342,14 +79784,21 @@ async function verifyPrompts(options = DEFAULT_VERIFY_PROMPTS_OPTIONS) {
     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;
         }
@@ -79359,10 +79808,20 @@ async function verifyPrompts(options = DEFAULT_VERIFY_PROMPTS_OPTIONS) {
             console.info(colors.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.
  */
@@ -79370,6 +79829,11 @@ function parseVerifyPromptsCliOptions(args) {
     return {
         reverse: args.includes('--reverse'),
         ignore: readRepeatableStringOption(args, '--ignore'),
+        gitSync: {
+            isCommitEnabled: args.includes('--commit'),
+            isAutoPushEnabled: args.includes('--auto-push'),
+            isAutoPullEnabled: args.includes('--auto-pull'),
+        },
     };
 }
 /**
@@ -79421,10 +79885,11 @@ async function prepareArchiveDirectory() {
  * 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,
     };
 }
 /**
@@ -79555,7 +80020,6 @@ function findFileWithAllDonePrompts(promptFiles, skippedFiles) {
 /**
  * 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;
@@ -79575,31 +80039,44 @@ async function verifyDonePromptsInFile(file) {
     }
     if (!lastDoneSection) {
         console.info(colors.gray('No done [x] prompts found in this file.'));
-        return false;
+        return { wasSkipped: false, commitMessage: null };
     }
     console.info(colors.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.yellow('\n⚠️  This prompt needs repair.'));
         await appendRepairPrompt(file, lastDoneSection);
-        return false;
+        return { wasSkipped: false, commitMessage: buildRepairCommitMessage(file) };
     }
     else {
         console.info(colors.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 { default: prompts } = await loadPromptsModule();
     const response = await prompts({
         type: 'select',
         name: 'verified',
@@ -79668,16 +80145,17 @@ async function resolvePrompt(selection) {
     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 { default: prompts } = await loadPromptsModule();
     const response = await prompts({
         type: 'select',
         name: 'decision',