@promptbook/cli 0.114.0-1 → 0.114.0-3

package/esm/index.es.js

@@ -9,16 +9,11 @@ import moment from 'moment';
 import * as fs from 'fs';
 import { createWriteStream, mkdirSync, writeFileSync, statSync, readFileSync, existsSync, promises } from 'fs';
 import * as dotenv from 'dotenv';
-import prompts from 'prompts';
 import * as readline from 'readline';
 import { emitKeypressEvents, clearLine, cursorTo, createInterface } from 'readline';
 import { forTime, forEver } from 'waitasecond';
 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 { 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-1';
+const PROMPTBOOK_ENGINE_VERSION = '0.114.0-3';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -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({
@@ -26966,12 +26967,12 @@ function buildControlPills(options) {
  * Builds the coder-run control pills shown in the footer box.
  */
 function buildCoderRunControlPills(options) {
-    const { pauseControl, pendingEnterLabel, isEndAfterCurrentPromptRequested, sessionTotal } = options;
+    const { phase, pauseControl, pendingEnterLabel, isEndAfterCurrentPromptRequested, sessionTotal } = options;
     return buildControlPills({
         pauseControl,
         pendingEnterLabel,
         additionalControls: [
-            buildSkipCurrentWaitControl(),
+            ...(phase === 'waiting' ? [buildSkipCurrentWaitControl()] : []),
             buildEndAfterCurrentPromptControl(isEndAfterCurrentPromptRequested, sessionTotal),
         ],
     });
@@ -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');
 }
@@ -29552,6 +29560,7 @@ function buildCodexScript(options) {
         `    -c model_reasoning_effort="${thinkingLevel}" \\`,
         `    --ask-for-approval ${options.askForApproval} \\`,
         `    exec --model ${options.model} \\`,
+        ...(options.isMachineReadableProgressEnabled ? ['    --json \\'] : []),
         '    --local-provider none \\',
         `    --sandbox ${options.sandbox} \\`,
         `    -C ${projectPath} \\`,
@@ -29868,6 +29877,10 @@ function matchesAnyPattern(text, patterns) {
  * Output line that marks finished Codex usage summary.
  */
 const CODEX_COMPLETION_LINE = /^\s*tokens used\b/i;
+/**
+ * Output line that marks the completed Codex turn in JSONL output mode.
+ */
+const CODEX_JSON_COMPLETION_LINE = /^\s*\{"type":"turn\.(?:completed|failed)"/u;
 /**
  * Idle timeout after completion marker to capture trailing output.
  */
@@ -29944,6 +29957,7 @@ class OpenAiCodexRunner {
             sandbox: this.options.sandbox,
             askForApproval: this.options.askForApproval,
             allowCredits: this.options.allowCredits,
+            isMachineReadableProgressEnabled: this.options.isMachineReadableProgressEnabled,
             codexCommand: this.options.codexCommand,
         });
         for (let retryIndex = 0;; retryIndex++) {
@@ -29958,7 +29972,9 @@ class OpenAiCodexRunner {
                 const output = await $runGoScriptUntilMarkerIdle({
                     scriptPath: options.scriptPath,
                     scriptContent,
-                    completionLineMatcher: CODEX_COMPLETION_LINE,
+                    completionLineMatcher: this.options.isMachineReadableProgressEnabled
+                        ? CODEX_JSON_COMPLETION_LINE
+                        : CODEX_COMPLETION_LINE,
                     idleTimeoutMs: CODEX_COMPLETION_IDLE_MS,
                     logPath: options.logPath,
                     shouldPrintLiveOutput: options.shouldPrintLiveOutput,
@@ -30208,6 +30224,7 @@ function createOpenAiCodexRunnerResolution(options) {
         sandbox: 'danger-full-access',
         askForApproval: 'never',
         allowCredits: options.allowCredits,
+        isMachineReadableProgressEnabled: options.isMachineReadableProgressEnabled,
     });
     if (!options.allowCredits && options.isVerbose === true) {
         console.info(colors.gray('OpenAI Codex credit spending is disabled. Use `--allow-credits` to explicitly opt in.'));
@@ -31443,6 +31460,7 @@ function buildCoderRunUiFrame(options) {
         : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
     const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
     const controls = buildCoderRunControlPills({
+        phase: options.phase,
         pauseControl: pausePresentation.pauseControl,
         pendingEnterLabel: options.pendingEnterLabel,
         isEndAfterCurrentPromptRequested: options.isEndAfterCurrentPromptRequested,
@@ -32306,6 +32324,7 @@ function createCoderRunOptionsForAgent(options) {
         autoPull: options.autoPull,
         agentName: options.agentName,
         model: options.model,
+        isMachineReadableProgressEnabled: options.isMachineReadableProgressEnabled,
         priority: 0,
     };
 }
@@ -32927,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 });
@@ -32936,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,
@@ -33295,6 +33321,21 @@ function appendCoderContext(prompt, context) {
         `);
 }
 
+/**
+ * Maximum amount of test output embedded into an agent prompt.
+ */
+const MAX_TEST_OUTPUT_CHARS = 12000;
+/**
+ * Limits test output while keeping the end of the output, where test runners usually print the failure summary.
+ */
+function limitTestOutput(testOutput) {
+    const normalizedTestOutput = testOutput.trim();
+    if (normalizedTestOutput.length <= MAX_TEST_OUTPUT_CHARS) {
+        return normalizedTestOutput;
+    }
+    return `[..., test output truncated to the last ${MAX_TEST_OUTPUT_CHARS} characters...]\n${normalizedTestOutput.slice(-MAX_TEST_OUTPUT_CHARS)}`;
+}
+
 /**
  * Runs the configured verification command inside the project root and returns its output.
  */
@@ -33315,10 +33356,6 @@ async function runPromptTestCommand(options) {
  * Maximum number of coding attempts allowed for the same prompt when verification keeps failing.
  */
 const MAX_PROMPT_TEST_ATTEMPTS = 3;
-/**
- * Maximum amount of verification output sent back to the coding agent as retry feedback.
- */
-const MAX_TEST_FEEDBACK_OUTPUT_CHARS = 12000;
 /**
  * File extension used by generated shell scripts.
  */
@@ -33364,7 +33401,7 @@ async function runPromptWithTestFeedback(options) {
             return { ...result, attemptCount, steps };
         }
         const fullVerificationOutput = formatUnknownErrorDetails(failedVerification.error);
-        const feedbackVerificationOutput = limitVerificationOutputForFeedback(fullVerificationOutput);
+        const feedbackVerificationOutput = limitTestOutput(fullVerificationOutput);
         if (attemptCount >= MAX_PROMPT_TEST_ATTEMPTS) {
             console.error(colors.red(`Verification failed for ${options.promptLabel} after ${attemptCount} attempts.`));
             throw new Error(buildFinalVerificationFailureMessage({
@@ -33494,19 +33531,6 @@ function buildFinalVerificationFailureMessage({ promptLabel, testCommand, attemp
             \`\`\`
         `);
 }
-/**
- * Limits verification output before it is embedded back into the next coding prompt.
- */
-function limitVerificationOutputForFeedback(verificationOutput) {
-    const normalizedVerificationOutput = verificationOutput.trim();
-    if (normalizedVerificationOutput.length <= MAX_TEST_FEEDBACK_OUTPUT_CHARS) {
-        return normalizedVerificationOutput;
-    }
-    return spaceTrim(`
-        [...verification output truncated to the last ${MAX_TEST_FEEDBACK_OUTPUT_CHARS} characters...]
-        ${normalizedVerificationOutput.slice(-MAX_TEST_FEEDBACK_OUTPUT_CHARS)}
-    `);
-}
 /**
  * Derives a dedicated temp-script path for verification commands.
  */
@@ -41367,6 +41391,7 @@ function createLocalAgentRunOptions(options, localAgentRunnerLimits) {
         autoClone: false,
         maxMessageProcessingFailures: localAgentRunnerLimits.maxFailedAttempts,
         maxParallelMessages: localAgentRunnerLimits.maxParallelMessages,
+        isMachineReadableProgressEnabled: true,
     };
 }
 
@@ -42277,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.
  *
@@ -42530,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(`
@@ -42548,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`,
+        });
     }));
 }
 /**
@@ -42630,6 +42753,7 @@ async function resolveCoderPromptDescription(descriptionArgument) {
         }
         return standardInputDescription;
     }
+    const { default: prompts } = await loadPromptsModule();
     const response = await prompts({
         type: 'text',
         name: 'description',
@@ -43050,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.
@@ -43061,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);
     }));
 }
@@ -43481,6 +43618,27 @@ function resolveCheckedHarnessDefinitions(harnessNames) {
 }
 // Note: [🟡] Code for CLI harness installation orchestration [$ensureHarnessInstallations](src/cli/cli-commands/common/harness/$ensureHarnessInstallations.ts) should never be published outside of `@promptbook/cli`
 
+/**
+ * Relative path to the Promptbook Coder quick-reference file initialized in project roots.
+ *
+ * @private internal utility of `ptbk coder`
+ */
+const AGENT_CODING_FILE_PATH = 'AGENT_CODING.md';
+/**
+ * Returns the default coder `AGENT_CODING.md` quick-reference content.
+ *
+ * @private internal utility of `ptbk coder`
+ */
+function getDefaultCoderAgentCodingFileContent() {
+    return spaceTrim$1(`
+        # ✨ Promptbook Coder agent coding
+
+        This project is using [Promptbook Coder](https://coder.ptbk.io) or run \`ptbk coder\`!
+    `);
+}
+// Note: [🟡] Code for coder AGENT_CODING file boilerplate [agentCodingFile](src/cli/cli-commands/coder/agentCodingFile.ts) should never be published outside of `@promptbook/cli`
+// Note: [💞] Ignore a discrepancy between file name and exported helper names
+
 /**
  * Relative path to the shared coder context file initialized in project roots.
  *
@@ -43508,106 +43666,6 @@ function getDefaultCoderAgentsFileContent() {
 // Note: [🟡] Code for coder AGENTS file boilerplate [agentsFile](src/cli/cli-commands/coder/agentsFile.ts) should never be published outside of `@promptbook/cli`
 // Note: [💞] Ignore a discrepancy between file name and exported helper names
 
-/**
- * Normalizes one project-relative path for human-readable CLI output and markdown.
- *
- * @private internal utility of `ptbk coder`
- */
-function formatDisplayPath(relativePath) {
-    return relativePath.replace(/\\/gu, '/');
-}
-// Note: [🟡] Code for coder path formatting [formatDisplayPath](src/cli/cli-commands/coder/formatDisplayPath.ts) should never be published outside of `@promptbook/cli`
-
-/**
- * Relative path to the Promptbook Coder quick-reference file initialized in project roots.
- *
- * @private internal utility of `ptbk coder`
- */
-const AGENT_CODING_FILE_PATH = 'AGENT_CODING.md';
-/**
- * Returns the default coder `AGENT_CODING.md` quick-reference content.
- *
- * @private internal utility of `ptbk coder`
- */
-function getDefaultCoderAgentCodingFileContent({ packageJsonScripts, }) {
-    return spaceTrim$1((block) => `
-            # Promptbook Coder quick reference
-
-            This project is prepared for the \`ptbk coder\` workflow. Promptbook Coder does not create a new model on its own; it orchestrates coding agents such as GitHub Copilot, OpenAI Codex, Claude Code, Opencode, Cline, and Gemini CLI through prompt files in \`${formatDisplayPath(PROMPTS_DIRECTORY_PATH)}/\`.
-
-            ## Workflow
-            1. Put repository-wide coding rules into \`${AGENTS_FILE_PATH}\`. The default \`npm run coder:run\` script already passes \`--context ${AGENTS_FILE_PATH}\`.
-            2. Create or customize prompt templates in \`${formatDisplayPath(PROMPTS_TEMPLATES_DIRECTORY_PATH)}/\`. ${buildStarterTemplateSentence()}
-            3. Generate prompt files with \`npm run coder:generate-boilerplates\` or \`ptbk coder generate-boilerplates --template <template> --count <count>\`. To append a single ready-to-run prompt straight from a description, use \`npm run coder:add\` or \`ptbk coder add "some new feature"\`.
-            4. Replace every \`@@@\`, keep drafts as \`[-]\`, and switch prompts to \`[ ]\` when they are ready to run. Completed prompts are marked \`[x]\`.
-            5. Run \`npm run coder:run\` to execute the next ready prompt with the configured coding agent.
-            6. Use \`npm run coder:verify\` to archive finished prompts into \`${formatDisplayPath(PROMPTS_DONE_DIRECTORY_PATH)}/\` and append repair follow-up prompts when more work is needed.
-            7. Use \`ptbk coder find-refactor-candidates\` when you want Promptbook to suggest refactor prompts automatically.
-
-            ## Templates
-            -   Project-owned templates created by \`ptbk coder init\`: ${formatInlineCodeList(getDefaultCoderProjectPromptTemplateDefinitions().map(({ relativeFilePath }) => formatDisplayPath(relativeFilePath)))}
-            -   Built-in \`--template\` aliases: ${formatInlineCodeList(getDefaultCoderPromptTemplateDefinitions().map(({ id }) => id))}
-            -   To add a custom template, create a markdown file such as \`${formatDisplayPath(PROMPTS_TEMPLATES_DIRECTORY_PATH)}/backend.md\`.
-            -   To use a project template, run \`ptbk coder generate-boilerplates --template ${formatDisplayPath(PROMPTS_TEMPLATES_DIRECTORY_PATH)}/backend.md\`.
-            -   Keep shared repository rules in \`${AGENTS_FILE_PATH}\` and recurring task-family rules in template files so individual prompt files stay focused on the actual task.
-
-            ## Created npm scripts
-            | Script | Purpose |
-            | --- | --- |
-            ${block(buildPackageJsonScriptTableLines(packageJsonScripts).join('\n'))}
-
-            ## Customizing the workflow
-            -   Edit \`package.json\` if you want \`npm run coder:run\` to use another coding agent, model, thinking level, context file, or wait mode.
-            -   Use direct CLI commands when you need one-off flags such as \`--min-priority\`, \`--max-priority\`, \`--ignore-git-changes\`, \`--no-commit\`, \`--dry-run\`, \`--test\`, \`--allow-credits\`, or \`--auto-migrate\`.
-            -   Use \`ptbk coder --help\` and \`ptbk coder <command> --help\` for the full CLI reference.
-        `);
-}
-/**
- * Builds the sentence describing the starter templates created during initialization.
- */
-function buildStarterTemplateSentence() {
-    const starterTemplatePaths = getDefaultCoderProjectPromptTemplateDefinitions().map(({ relativeFilePath }) => formatDisplayPath(relativeFilePath));
-    if (starterTemplatePaths.length === 1) {
-        return `The starter project template created by \`ptbk coder init\` is \`${starterTemplatePaths[0]}\`.`;
-    }
-    return `The starter project templates created by \`ptbk coder init\` are ${formatInlineCodeList(starterTemplatePaths)}.`;
-}
-/**
- * Builds the markdown table rows describing the initialized npm scripts.
- */
-function buildPackageJsonScriptTableLines(packageJsonScripts) {
-    return Object.entries(packageJsonScripts).map(([scriptName, scriptCommand]) => `| \`npm run ${scriptName}\` | ${describeDefaultCoderPackageJsonScript(scriptName, scriptCommand)} |`);
-}
-/**
- * Describes one initialized npm script in human-readable terms.
- */
-function describeDefaultCoderPackageJsonScript(scriptName, scriptCommand) {
-    if (scriptName === 'coder:generate-boilerplates') {
-        return `Runs \`${scriptCommand}\` to create new prompt files in \`${formatDisplayPath(PROMPTS_DIRECTORY_PATH)}/\`.`;
-    }
-    if (scriptName === 'coder:add') {
-        return `Runs \`${scriptCommand}\` to add one ready-to-run prompt file to \`${formatDisplayPath(PROMPTS_DIRECTORY_PATH)}/\` from a plain-language description.`;
-    }
-    if (scriptName === 'coder:run') {
-        return `Runs \`${scriptCommand}\` to execute the next ready prompt with shared repository context from \`${AGENTS_FILE_PATH}\`.`;
-    }
-    if (scriptName === 'coder:find-refactor-candidates') {
-        return `Runs \`${scriptCommand}\` to generate prompt candidates for large or crowded files.`;
-    }
-    if (scriptName === 'coder:verify') {
-        return `Runs \`${scriptCommand}\` to archive verified prompts into \`${formatDisplayPath(PROMPTS_DONE_DIRECTORY_PATH)}/\` and append repair prompts when needed.`;
-    }
-    return `Runs \`${scriptCommand}\`.`;
-}
-/**
- * Formats one inline code list for human-readable markdown.
- */
-function formatInlineCodeList(values) {
-    return values.map((value) => `\`${value}\``).join(', ');
-}
-// Note: [🟡] Code for coder AGENT_CODING file boilerplate [agentCodingFile](src/cli/cli-commands/coder/agentCodingFile.ts) should never be published outside of `@promptbook/cli`
-// Note: [💞] Ignore a discrepancy between file name and exported helper names
-
 /**
  * Relative directory path for agents initialized by `ptbk coder init`.
  *
@@ -43672,6 +43730,16 @@ async function isExistingFile$2(path) {
 }
 // Note: [🟡] Code for coder init developer agent bootstrapping [ensureCoderDeveloperAgentFile](src/cli/cli-commands/coder/ensureCoderDeveloperAgentFile.ts) should never be published outside of `@promptbook/cli`
 
+/**
+ * Normalizes one project-relative path for human-readable CLI output and markdown.
+ *
+ * @private internal utility of `ptbk coder`
+ */
+function formatDisplayPath(relativePath) {
+    return relativePath.replace(/\\/gu, '/');
+}
+// Note: [🟡] Code for coder path formatting [formatDisplayPath](src/cli/cli-commands/coder/formatDisplayPath.ts) should never be published outside of `@promptbook/cli`
+
 /**
  * Fallback `.env` content used when no required variables need to be appended.
  */
@@ -43749,7 +43817,7 @@ async function ensureCoderGitignoreFile(projectPath) {
 const DEFAULT_CODER_PACKAGE_JSON_SCRIPTS = {
     'coder:generate-boilerplates': 'ptbk coder generate-boilerplates --template ./prompts/templates/common.md',
     'coder:add': 'ptbk coder add --template ./prompts/templates/common.md',
-    'coder:run': 'ptbk coder run --harness openai-codex --model gpt-5.5 --thinking-level xhigh --agent agents/developer.book --context AGENTS.md',
+    'coder:run': 'ptbk coder run --harness openai-codex --model gpt-5.6-terra --thinking-level max --agent agents/developer.book --context AGENTS.md --test-before yes-and-fix',
     // 'coder:find-refactor-candidates': 'npx ptbk coder find-refactor-candidates',
     'coder:verify': 'ptbk coder verify',
 };
@@ -43998,9 +44066,7 @@ async function initializeCoderProjectConfiguration(projectPath) {
     const agentsDirectoryStatus = await ensureDirectory(projectPath, CODER_AGENTS_DIRECTORY_PATH);
     const developerAgentFileStatus = await ensureCoderDeveloperAgentFile(projectPath);
     const agentsFileStatus = await ensureCoderMarkdownFile(projectPath, AGENTS_FILE_PATH, getDefaultCoderAgentsFileContent());
-    const agentCodingFileStatus = await ensureCoderMarkdownFile(projectPath, AGENT_CODING_FILE_PATH, getDefaultCoderAgentCodingFileContent({
-        packageJsonScripts: getDefaultCoderPackageJsonScripts(),
-    }));
+    const agentCodingFileStatus = await ensureCoderMarkdownFile(projectPath, AGENT_CODING_FILE_PATH, getDefaultCoderAgentCodingFileContent());
     const { envFileStatus, initializedEnvVariableNames } = await ensureCoderEnvFile(projectPath);
     const gitignoreFileStatus = await ensureCoderGitignoreFile(projectPath);
     const packageJsonFileStatus = await ensureCoderPackageJsonFile(projectPath);
@@ -44115,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);
     }));
 }
@@ -44141,6 +44219,48 @@ function listDefaultCoderProjectPromptTemplateDisplayPaths() {
 // Note: [🟡] Code for CLI command [init](src/cli/cli-commands/coder/init.ts) should never be published outside of `@promptbook/cli`
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
+/**
+ * Initializes `coder ping` command for Promptbook CLI utilities
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it registers a command in the CLI
+ *
+ * @private internal function of `promptbookCli`
+ */
+function $initializeCoderPingCommand(program) {
+    const command = program.command('ping');
+    command.description(spaceTrim$1(`
+            Send one tiny dummy prompt to a harness and model to measure and warm them up
+
+            ${PROMPT_RUNNER_DESCRIPTION}
+
+            Features:
+            - Verifies that the selected harness, model, thinking level and authentication really work
+            - Reports the answer of the harness, the response time and the reported usage
+            - Starts the hourly/weekly quota window before you need it, so it is already refreshing when you do
+            - Leaves the project exactly as it was — nothing is read, written, changed or committed
+            - Use --no-ui to stream the raw harness output instead of only the compact result
+        `));
+    addPromptRunnerSelectionOptions(command);
+    addPromptRunnerRuntimeOptions(command);
+    command.action(handleActionErrors(async (cliOptions) => {
+        const runnerOptions = normalizePromptRunnerSelectionCliOptions(cliOptions, { isAgentRequired: true });
+        await $ensureHarnessInstallations([runnerOptions.agentName]);
+        // Note: Import the ping dynamically to avoid loading heavy dependencies until needed
+        const { pingCoderHarness } = await Promise.resolve().then(function () { return pingCoderHarness$1; });
+        const { printCoderPingResult } = await Promise.resolve().then(function () { return printCoderPingResult$1; });
+        const result = await pingCoderHarness({
+            agentName: runnerOptions.agentName,
+            model: runnerOptions.model,
+            thinkingLevel: runnerOptions.thinkingLevel,
+            allowCredits: runnerOptions.allowCredits,
+            shouldPrintLiveOutput: runnerOptions.noUi,
+        });
+        printCoderPingResult(result);
+    }));
+}
+// Note: [🟡] Code for CLI command [ping](src/cli/cli-commands/coder/ping.ts) should never be published outside of `@promptbook/cli`
+// Note: [💞] Ignore a discrepancy between file name and entity name
+
 /**
  * Creates a Commander argument parser that accepts only non-negative integers.
  *
@@ -44165,6 +44285,21 @@ function createNonNegativeIntegerOptionParser(optionName) {
 }
 // Note: [🟡] Code for CLI option parser [createNonNegativeIntegerOptionParser](src/cli/cli-commands/common/createNonNegativeIntegerOptionParser.ts) should never be published outside of `@promptbook/cli`
 
+/**
+ * Modes supported by `ptbk coder run --test-before`.
+ */
+const TEST_BEFORE_MODE_VALUES = ['no', 'yes-and-fail', 'yes-and-fix'];
+/**
+ * Default verification command used when a pre-coding mode is enabled without an explicit `--test` command.
+ */
+const DEFAULT_CODER_TEST_COMMAND = 'npm test';
+/**
+ * Checks whether a value is a supported `--test-before` mode.
+ */
+function isTestBeforeMode(value) {
+    return TEST_BEFORE_MODE_VALUES.includes(value);
+}
+
 /**
  * Default wait duration applied before retrying a prompt round after an error (10 minutes).
  *
@@ -44209,6 +44344,7 @@ function $initializeCoderRunCommand(program) {
             - Optional --no-ui keeps plain streaming console output for logging and debugging
             - Checks that the selected harness is installed globally and up to date before the first prompt
             - Supports GPG signing of commits
+            - Optional pre-coding test run that can stop or repair pre-existing failures
             - Optional post-prompt verification with test-feedback retries
             - Progress tracking and interactive P/S/X terminal controls
             - Dry-run mode to preview prompts
@@ -44218,6 +44354,9 @@ function $initializeCoderRunCommand(program) {
     command.option('--agent <agent-book-path>', 'Path to a .book file whose compiled system message is prepended to each coding prompt');
     command.option('--context <context-or-file>', 'Append extra instructions either inline or from a file path relative to the current project');
     command.option('--test <test-command...>', 'Run a verification command after each prompt; quote it when the command itself contains top-level flags');
+    command.addOption(new Option('--test-before <mode>', `Run tests before coding: ${TEST_BEFORE_MODE_VALUES.join(', ')} (defaults to no; uses npm test when --test is omitted)`)
+        .choices([...TEST_BEFORE_MODE_VALUES])
+        .default('no'));
     command.option('--preserve-logs', 'Keep generated temp prompt/log artifacts after successful rounds for debugging and analytics', false);
     addPromptRunnerExecutionOptions(command);
     command.option('--isolate', spaceTrim$1(`
@@ -44247,8 +44386,9 @@ function $initializeCoderRunCommand(program) {
     command.option('--auto-migrate', 'Run testing-server database migrations automatically after each successfully processed prompt');
     command.option('--allow-destructive-auto-migrate', 'Allow auto-migrate even when heuristic SQL safety check flags destructive pending migrations');
     command.action(handleActionErrors(async (cliOptions) => {
-        const { dryRun, agent, context, test, preserveLogs, isolate: isIsolated, priority, minPriority: minimumPriority, maxPriority: maximumPriority, limit, waitAfterPrompt: waitAfterPromptValue, waitBetweenPrompts: waitBetweenPromptsValue, waitAfterError: waitAfterErrorValue, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
-        const testCommand = normalizeCommandOptionValue$1(test);
+        const { dryRun, agent, context, test, testBefore, preserveLogs, isolate: isIsolated, priority, minPriority: minimumPriority, maxPriority: maximumPriority, limit, waitAfterPrompt: waitAfterPromptValue, waitBetweenPrompts: waitBetweenPromptsValue, waitAfterError: waitAfterErrorValue, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
+        const configuredTestCommand = normalizeCommandOptionValue$1(test);
+        const testCommand = configuredTestCommand !== null && configuredTestCommand !== void 0 ? configuredTestCommand : (testBefore === 'no' ? undefined : DEFAULT_CODER_TEST_COMMAND);
         const runnerOptions = normalizePromptRunnerCliOptions(cliOptions, {
             isAgentRequired: !dryRun,
         });
@@ -44277,6 +44417,7 @@ function $initializeCoderRunCommand(program) {
             agent,
             context,
             testCommand,
+            testBefore,
             preserveLogs,
             isIsolated,
             noUi: runnerOptions.noUi,
@@ -44487,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);
@@ -44534,6 +44681,7 @@ function collectStringOption(value, previousValues) {
  * - generate-boilerplates: Generate prompt boilerplate files
  * - find-refactor-candidates: Find files that need refactoring
  * - run: Run coding prompts with AI agents
+ * - ping: Test one harness and model with a tiny dummy prompt
  * - verify: Verify completed prompts
  * - find-fresh-emoji-tags: Find unused emoji tags
  *
@@ -44553,6 +44701,7 @@ function $initializeCoderCommand(program) {
             - find-refactor-candidates: Find files that need refactoring
             - find-unwritten: List prompt sections that still need to be authored
             - run: Run coding prompts with AI agents
+            - ping: Test the connection, response time and quota of one harness and model
             - server: Start a long-running coder server with a kanban web UI
             - verify: Verify completed prompts
             - find-fresh-emoji-tags: Find unused emoji tags
@@ -44564,6 +44713,7 @@ function $initializeCoderCommand(program) {
     $initializeCoderFindRefactorCandidatesCommand(coderCommand);
     $initializeCoderFindUnwrittenCommand(coderCommand);
     $initializeCoderRunCommand(coderCommand);
+    $initializeCoderPingCommand(coderCommand);
     $initializeCoderServerCommand(coderCommand);
     $initializeCoderVerifyCommand(coderCommand);
     $initializeCoderFindFreshEmojiTagCommand(coderCommand);
@@ -45397,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.
  *
@@ -45425,6 +45583,7 @@ async function createRemoteClient(options) {
 
                     `));
     }
+    const { io } = await loadSocketIoClientModule();
     return new Promise((resolve, reject) => {
         const socket = io(remoteServerUrl, {
             retries: CONNECTION_RETRIES_LIMIT,
@@ -46092,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',
@@ -46467,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
  *
@@ -46481,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) {
@@ -50544,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
  *
@@ -50580,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,
         });
@@ -54183,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);
@@ -54811,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',
@@ -55118,6 +55307,7 @@ async function resolveRunPipelineSource(pipelineSource) {
     if (pipelineSource) {
         return pipelineSource;
     }
+    const { default: prompts } = await loadPromptsModule();
     const response = await prompts({
         type: 'text',
         name: 'pipelineSource',
@@ -55205,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 };
@@ -58110,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.
  *
@@ -58147,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;
@@ -58410,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.
  *
@@ -58443,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;
@@ -60252,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.
  *
@@ -60278,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;
@@ -67991,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',
@@ -69204,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.
  */
@@ -69257,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));
@@ -69269,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),
@@ -69480,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),
@@ -69694,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.',
@@ -69740,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,
@@ -69882,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;
@@ -72214,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.
  */
@@ -72688,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.
  *
@@ -72713,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}`);
@@ -72772,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 {
@@ -72785,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) {
@@ -72817,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;
@@ -72844,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) ||
@@ -72862,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));
 }
@@ -72874,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)) {
@@ -72893,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) ||
@@ -72918,6 +73245,7 @@ function isComplexityDecisionNode(node) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function getFunctionDisplayName(functionNode) {
+    const ts = getLoadedTypescriptModule();
     if (ts.isConstructorDeclaration(functionNode)) {
         return 'constructor';
     }
@@ -72950,6 +73278,7 @@ function getFunctionDisplayName(functionNode) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function getBindingNameText(name) {
+    const ts = getLoadedTypescriptModule();
     return ts.isIdentifier(name) ? name.text : null;
 }
 /**
@@ -72958,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;
     }
@@ -72980,6 +73310,7 @@ function buildComplexityReason(structureSummary, maxAllowedFunctionComplexity) {
  * @private function of analyzeSourceFileForRefactorCandidate
  */
 function getScriptKindForExtension(extension) {
+    const ts = getLoadedTypescriptModule();
     if (extension === '.tsx') {
         return ts.ScriptKind.TSX;
     }
@@ -73589,6 +73920,41 @@ function listPromptsToBeWritten(files, priorityFilter = {}) {
         isPromptInPriorityFilter(prompt.section, priorityFilter));
 }
 
+/**
+ * Checks whether a prompt is unrestricted or matches the selected harness/model.
+ *
+ * A prompt status line can contain one or more backtick-delimited model or harness
+ * names. Matching is intentionally based on normalized substrings so a token such as
+ * `gpt` selects any `gpt-*` model and `opus` selects a `claude-opus-*` model.
+ */
+function isPromptCompatibleWithRunner(file, section, promptRunnerIdentity) {
+    if (promptRunnerIdentity === undefined) {
+        return true;
+    }
+    const statusLine = section.statusLineIndex === undefined ? undefined : file.lines[section.statusLineIndex];
+    const requiredRunnerTokens = statusLine === undefined ? [] : extractPromptRunnerTokens(statusLine);
+    if (requiredRunnerTokens.length === 0) {
+        return true;
+    }
+    const normalizedRunnerNames = [promptRunnerIdentity.harnessName, promptRunnerIdentity.modelName]
+        .filter((name) => name !== undefined && name.trim() !== '')
+        .map((name) => normalizeToKebabCase(name))
+        .filter((name) => name !== '');
+    return requiredRunnerTokens.some((requiredRunnerToken) => {
+        const normalizedRequiredRunnerToken = normalizeToKebabCase(requiredRunnerToken);
+        return (normalizedRequiredRunnerToken !== '' &&
+            normalizedRunnerNames.some((normalizedRunnerName) => normalizedRunnerName.includes(normalizedRequiredRunnerToken)));
+    });
+}
+/**
+ * Extracts model and harness tokens from a prompt status line.
+ */
+function extractPromptRunnerTokens(statusLine) {
+    return Array.from(statusLine.matchAll(/`([^`]+)`/gu))
+        .map((match) => { var _a, _b; return (_b = (_a = match[1]) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : ''; })
+        .filter((token) => token !== '');
+}
+
 /**
  * Parses a prompt markdown file into sections and metadata.
  */
@@ -73636,11 +74002,11 @@ function parsePromptFile(filePath, content) {
     };
 }
 /**
- * Parses a status line like "[ ] !!" or "[-]" or "[x] ~$0.65 21 minutes..." into status and priority.
+ * Parses a status line like "[ ] !!", "[ ] use `gpt` !!!!!" or "[-]" into status and priority.
  * For [x] done and [!] failed prompts, allow metadata after the status marker.
  */
 function parseStatusLine(line) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     // For done prompts [x], allow any content after (for cost/time metadata)
     const doneMatch = line.match(/^\[(?<status>[xX])\]/);
     if (doneMatch) {
@@ -73651,21 +74017,23 @@ function parseStatusLine(line) {
     if (failedMatch) {
         return { status: 'failed', priority: 0 };
     }
-    // For todo [ ] and not-ready [-], require clean end with optional priority markers
-    const match = line.match(/^\[(?<status>[ -])\]\s*(?<priority>!*)\s*$/);
-    if (!match) {
-        return undefined;
+    // For not-ready [-], keep the historical clean-line syntax.
+    if (/^\[-\]\s*!*\s*$/u.test(line)) {
+        return { status: 'not-ready', priority: 0 };
     }
-    const statusChar = (_b = (_a = match.groups) === null || _a === void 0 ? void 0 : _a.status) === null || _b === void 0 ? void 0 : _b.toLowerCase();
-    let status;
-    if (statusChar === '-') {
-        status = 'not-ready';
+    // Todo [ ] may contain backtick-delimited model/harness tokens and priority markers
+    // before or after those tokens. Other trailing text remains an invalid status line.
+    const todoMatch = line.match(/^\[ \](?<details>.*)$/u);
+    if (!todoMatch) {
+        return undefined;
     }
-    else {
-        status = 'todo';
+    const details = (_b = (_a = todoMatch.groups) === null || _a === void 0 ? void 0 : _a.details) !== null && _b !== void 0 ? _b : '';
+    const isPriorityOnly = /^[!\s]*$/u.test(details);
+    const hasPromptRunnerTokens = extractPromptRunnerTokens(line).length > 0;
+    if (details.trim() !== '' && !isPriorityOnly && !hasPromptRunnerTokens) {
+        return undefined;
     }
-    const priority = status === 'todo' ? (_e = (_d = (_c = match.groups) === null || _c === void 0 ? void 0 : _c.priority) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0 : 0;
-    return { status, priority };
+    return { status: 'todo', priority: (_d = (_c = details.match(/!/gu)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0 };
 }
 /**
  * Finds the first non-empty line index between two bounds.
@@ -73801,6 +74169,243 @@ var findUnwrittenPrompts$1 = /*#__PURE__*/Object.freeze({
     findUnwrittenPrompts: findUnwrittenPrompts
 });
 
+/**
+ * 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);
+}
+
+/**
+ * Marker the pinged harness is asked to prefix its answer with, so the reply can be recognized
+ * in the raw runner output of every supported harness.
+ *
+ * Note: The marker must stay free of regular-expression metacharacters, because
+ *       `extractCoderPingAnswer` builds its pattern from it.
+ */
+const CODER_PING_ANSWER_MARKER = 'PTBK-CODER-PING-ANSWER';
+/**
+ * First factor of the dummy multiplication the pinged harness is asked to compute.
+ */
+const CODER_PING_FIRST_FACTOR = 6;
+/**
+ * Second factor of the dummy multiplication the pinged harness is asked to compute.
+ */
+const CODER_PING_SECOND_FACTOR = 7;
+/**
+ * Answer a working harness and model returns for the dummy work of `ptbk coder ping`.
+ */
+const CODER_PING_EXPECTED_ANSWER = String(CODER_PING_FIRST_FACTOR * CODER_PING_SECOND_FACTOR);
+/**
+ * Builds the dummy prompt sent by `ptbk coder ping`.
+ *
+ * The work is intentionally the smallest possible one that still reaches the model: it spends a
+ * negligible amount of the harness quota, it needs no tool and it explicitly forbids touching the
+ * project, so a ping leaves the project exactly as it was.
+ */
+function buildCoderPingPrompt() {
+    return spaceTrim(`
+        # Promptbook connection check
+
+        This is an automated \`ptbk coder ping\` connection check, not a coding task.
+
+        Do exactly this and nothing else:
+
+        1. Multiply \`${CODER_PING_FIRST_FACTOR}\` by \`${CODER_PING_SECOND_FACTOR}\`.
+        2. Answer with one single line \`${CODER_PING_ANSWER_MARKER}: <result>\` where \`<result>\` is the number you computed.
+
+        Rules:
+
+        - Do not read, create, change, move or delete any file.
+        - Do not run any command and do not use any tool.
+        - Do not write anything except the single answer line.
+    `);
+}
+
+/**
+ * Pattern matching one answer line produced by the pinged harness.
+ *
+ * The captured answer deliberately stops at a quote, a backslash or a line break, so an answer
+ * embedded in a JSON event stream — as produced by Claude Code, Opencode or Codex `--json` — is
+ * captured without the surrounding JSON.
+ */
+const CODER_PING_ANSWER_PATTERN = new RegExp(`${CODER_PING_ANSWER_MARKER}\\s*:[ \\t]*([^\\r\\n"\\\\]*)`, 'gu');
+/**
+ * Extracts the answer of a pinged harness from the runtime log of its runner shell.
+ *
+ * Only the raw output of the last execution is searched, so the answer marker contained in the
+ * prompt of the raw input is never mistaken for the answer of the harness.
+ *
+ * @returns The answer of the harness, or `null` when the harness produced no recognizable answer
+ */
+function extractCoderPingAnswer(runtimeLog) {
+    var _a;
+    const rawOutput = runtimeLog.split(SCRIPT_EXECUTION_LOG_RAW_OUTPUT_MARKER).pop();
+    if (rawOutput === undefined) {
+        return null;
+    }
+    // Note: The last answer wins because harnesses which stream partial messages repeat the growing answer line
+    const answers = Array.from(rawOutput.matchAll(CODER_PING_ANSWER_PATTERN))
+        .map((match) => (match[1] || '').trim())
+        .filter((answer) => answer !== '');
+    return (_a = answers[answers.length - 1]) !== null && _a !== void 0 ? _a : null;
+}
+
+/**
+ * Temporary subdirectory used for the `ptbk coder ping` runner shell script and its runtime log.
+ */
+const CODER_PING_SCRIPT_DIRECTORY_NAME = 'coder-ping';
+/**
+ * Base name of the temporary `ptbk coder ping` runner shell script.
+ */
+const CODER_PING_SCRIPT_SOURCE_NAME = 'ping';
+/**
+ * Sends one tiny dummy prompt through the selected harness and model and measures the round trip.
+ *
+ * The ping reuses the very same runner the coding queue uses, so it really exercises the configured
+ * harness, model, thinking level and authentication — including the retry behavior on rate limits.
+ * Both temporary artifacts it creates are removed again, so the project is left as it was.
+ */
+async function pingCoderHarness(options) {
+    const projectPath = options.projectPath || process.cwd();
+    const { runner, runnerMetadata } = resolvePromptRunner(options);
+    const scriptPath = buildTemporaryPromptScriptPath({
+        projectPath,
+        scriptDirectoryName: CODER_PING_SCRIPT_DIRECTORY_NAME,
+        sourceFileName: CODER_PING_SCRIPT_SOURCE_NAME,
+    });
+    const startedTimeMs = Date.now();
+    const { answer, usage, loginMethod } = await withPromptRuntimeLog(scriptPath, async (logPath) => {
+        var _a;
+        const result = await runner.runPrompt({
+            prompt: buildCoderPingPrompt(),
+            scriptPath,
+            projectPath,
+            logPath,
+            shouldPrintLiveOutput: (_a = options.shouldPrintLiveOutput) !== null && _a !== void 0 ? _a : false,
+            preserveArtifactsOnSuccess: false,
+        });
+        return { ...result, answer: extractCoderPingAnswer(await readRuntimeLog(logPath)) };
+    }, { preserveArtifactsOnSuccess: false });
+    return {
+        runnerName: runnerMetadata.runnerName,
+        modelName: runnerMetadata.modelName,
+        thinkingLevel: options.thinkingLevel,
+        answer,
+        isAnswerCorrect: answer === CODER_PING_EXPECTED_ANSWER,
+        durationMs: Date.now() - startedTimeMs,
+        usage,
+        loginMethod,
+    };
+}
+/**
+ * Reads the runtime log of the finished ping, treating an unreadable log as no output at all.
+ */
+async function readRuntimeLog(logPath) {
+    return await readFile(logPath, 'utf-8').catch(() => '');
+}
+
+var pingCoderHarness$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    pingCoderHarness: pingCoderHarness
+});
+
+/**
+ * Formats usage price for display in prompt status lines and task details.
+ * Examples:
+ * - "$0.12" (certain)
+ * - "~$3.05" (uncertain)
+ * - "$0.00" (zero cost)
+ * - "<$0.01" (tiny non-zero cost)
+ *
+ * @private internal utility of the prompt runners and the Agents Server task details
+ */
+function formatUsagePrice(usage) {
+    const price = usage.price.value;
+    const isUncertain = usage.price.isUncertain === true;
+    const prefix = isUncertain ? '~' : '';
+    if (price === 0) {
+        return `${prefix}$0.00`;
+    }
+    if (price < 0.01) {
+        return `${prefix}<$0.01`;
+    }
+    if (price < 1) {
+        return `${prefix}$${price.toFixed(4)}`;
+    }
+    return `${prefix}$${price.toFixed(2)}`;
+}
+
+/**
+ * Formats runner details for prompt status lines.
+ */
+function formatRunnerSignature(runnerName, modelName, thinkingLevel) {
+    const normalizedRunner = runnerName === null || runnerName === void 0 ? void 0 : runnerName.trim();
+    const normalizedModel = modelName === null || modelName === void 0 ? void 0 : modelName.trim();
+    const thinkingLevelSuffix = thinkingLevel ? ` thinking \`${thinkingLevel}\`` : '';
+    if (!normalizedRunner && !normalizedModel) {
+        return 'unknown';
+    }
+    const runnerLabel = normalizedRunner || 'unknown';
+    if (!normalizedModel) {
+        return `${runnerLabel}${thinkingLevelSuffix}`;
+    }
+    return `${runnerLabel} \`${normalizedModel}\`${thinkingLevelSuffix}`;
+}
+
+/**
+ * Prints the compact summary of one finished `ptbk coder ping`.
+ */
+function printCoderPingResult(result) {
+    const runnerSignature = formatRunnerSignature(result.runnerName, result.modelName, result.thinkingLevel);
+    const loginMethodLabel = formatCodexLoginMethod(result.loginMethod);
+    const loginMethodSuffix = loginMethodLabel === undefined ? '' : ` (${loginMethodLabel})`;
+    console.info(colors.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,
+    printCoderPingResult: printCoderPingResult
+});
+
 /**
  * Default wait duration applied before retrying a failed prompt round.
  */
@@ -73808,7 +74413,7 @@ const DEFAULT_WAIT_AFTER_ERROR_MS = 10 * 60 * 1000;
 /**
  * CLI usage text for this script.
  */
-const USAGE = 'Usage: run-codex-prompts [--dry-run] [--harness <harness-name>] [--model <model>] [--context <context-or-file>] [--test <test-command...>] [--preserve-logs] [--isolate] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--min-priority <minimum-priority>] [--max-priority <maximum-priority>] [--limit <run-count>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--wait-after-prompt <duration>] [--wait-between-prompts <duration>] [--wait-after-error <duration>] [--no-auto] [--no-commit] [--ignore-git-changes] [--no-normalize-line-endings] [--auto-push] [--auto-pull]';
+const USAGE = 'Usage: run-codex-prompts [--dry-run] [--harness <harness-name>] [--model <model>] [--context <context-or-file>] [--test <test-command...>] [--test-before <no|yes-and-fail|yes-and-fix>] [--preserve-logs] [--isolate] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--min-priority <minimum-priority>] [--max-priority <maximum-priority>] [--limit <run-count>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--wait-after-prompt <duration>] [--wait-between-prompts <duration>] [--wait-after-error <duration>] [--no-auto] [--no-commit] [--ignore-git-changes] [--no-normalize-line-endings] [--auto-push] [--auto-pull]';
 /**
  * Top-level flags supported by this command.
  */
@@ -73818,6 +74423,7 @@ const KNOWN_OPTION_FLAGS = new Set([
     '--model',
     '--context',
     '--test',
+    '--test-before',
     '--preserve-logs',
     '--isolate',
     '--no-ui',
@@ -73856,6 +74462,8 @@ function parseRunOptions(args) {
     const context = readOptionValue(args, '--context');
     const hasTestCommandFlag = args.includes('--test');
     const testCommand = readVariadicOptionValue(args, '--test');
+    const hasTestBeforeFlag = args.includes('--test-before');
+    const testBefore = parseTestBeforeOption(readOptionValue(args, '--test-before'), hasTestBeforeFlag);
     const preserveLogs = args.includes('--preserve-logs');
     const isIsolated = args.includes('--isolate');
     const noUi = args.includes('--no-ui');
@@ -73928,6 +74536,7 @@ function parseRunOptions(args) {
         model,
         context,
         testCommand,
+        testBefore,
         thinkingLevel,
         priority: minimumPriority !== null && minimumPriority !== void 0 ? minimumPriority : 0,
         minimumPriority,
@@ -73936,6 +74545,21 @@ function parseRunOptions(args) {
         limit,
     };
 }
+/**
+ * Parses and validates the optional pre-coding verification mode.
+ */
+function parseTestBeforeOption(value, hasTestBeforeFlag) {
+    if (value === undefined) {
+        if (hasTestBeforeFlag) {
+            exitWithUsageError(`Missing value for --test-before. Use one of: ${TEST_BEFORE_MODE_VALUES.join(', ')}.`);
+        }
+        return 'no';
+    }
+    if (!isTestBeforeMode(value)) {
+        exitWithUsageError(`Invalid value for --test-before: "${value}". Use one of: ${TEST_BEFORE_MODE_VALUES.join(', ')}.`);
+    }
+    return value;
+}
 /**
  * Reads a duration-typed CLI flag, applying the provided default when the flag is absent.
  */
@@ -75694,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.
  */
@@ -75771,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 },
@@ -75928,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.
  *
@@ -75963,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.
  */
@@ -76034,20 +76632,13 @@ function formatPromptAttemptMetadata(status, attemptCount) {
 }
 
 /**
- * Formats runner details for prompt status lines.
+ * Replaces the complete todo status line while preserving its indentation.
+ *
+ * The complete line is replaced because a todo status can contain a required
+ * model/harness token in addition to priority markers.
  */
-function formatRunnerSignature(runnerName, modelName, thinkingLevel) {
-    const normalizedRunner = runnerName === null || runnerName === void 0 ? void 0 : runnerName.trim();
-    const normalizedModel = modelName === null || modelName === void 0 ? void 0 : modelName.trim();
-    const thinkingLevelSuffix = thinkingLevel ? ` thinking \`${thinkingLevel}\`` : '';
-    if (!normalizedRunner && !normalizedModel) {
-        return 'unknown';
-    }
-    const runnerLabel = normalizedRunner || 'unknown';
-    if (!normalizedModel) {
-        return `${runnerLabel}${thinkingLevelSuffix}`;
-    }
-    return `${runnerLabel} \`${normalizedModel}\`${thinkingLevelSuffix}`;
+function replacePromptTodoStatusLine(line, replacementStatusLine) {
+    return line.replace(/^(?<indentation>\s*)\[\s*\].*$/u, `$<indentation>${replacementStatusLine}`);
 }
 
 /**
@@ -76067,8 +76658,8 @@ function markPromptDone(file, section, steps, runnerName, modelName, attemptCoun
     const loginMethodSuffix = loginMethodLabel ? ` (${loginMethodLabel})` : '';
     const stepsSummary = formatCoderRunSteps(steps);
     const stepsSuffix = stepsSummary === '' ? '' : ` - ${stepsSummary}`;
-    // Replace "[ ]" or "[ ] !!..." with "[x] by runner model thinking level (login method) - Step $price duration; ..."
-    file.lines[section.statusLineIndex] = line.replace(/\[\s*\]\s*!*\s*$/, `[x] ${attemptMetadata}by ${runnerSignature}${loginMethodSuffix}${stepsSuffix}`);
+    // Replace the complete todo status, including any required model/harness token.
+    file.lines[section.statusLineIndex] = replacePromptTodoStatusLine(line, `[x] ${attemptMetadata}by ${runnerSignature}${loginMethodSuffix}${stepsSuffix}`);
 }
 
 /**
@@ -76086,8 +76677,10 @@ function markPromptFailed(file, section, runnerName, modelName, promptExecutionS
     const attemptMetadata = formatPromptAttemptMetadata('failed', attemptCount);
     const duration = moment().diff(promptExecutionStartedDate);
     const durationString = moment.duration(duration).humanize();
-    const failureDetails = attemptMetadata === '' ? `failed after ${durationString} by ${runnerSignature}` : `${attemptMetadata}${durationString} by ${runnerSignature}`;
-    file.lines[section.statusLineIndex] = line.replace(/\[\s*\]\s*!*\s*$/, `[!] ${failureDetails}`);
+    const failureDetails = attemptMetadata === ''
+        ? `failed after ${durationString} by ${runnerSignature}`
+        : `${attemptMetadata}${durationString} by ${runnerSignature}`;
+    file.lines[section.statusLineIndex] = replacePromptTodoStatusLine(line, `[!] ${failureDetails}`);
 }
 
 /**
@@ -77057,17 +77650,18 @@ function toProjectRelativeGitPath(projectPath, path) {
 /**
  * Lists todo prompts that are ready to run (no authoring placeholders).
  */
-function listRunnablePrompts(files, priorityFilter = {}) {
+function listRunnablePrompts(files, priorityFilter = {}, promptRunnerIdentity) {
     return listTodoPrompts(files).filter((prompt) => !isPromptToBeWritten(prompt.file, prompt.section) &&
-        isPromptInPriorityFilter(prompt.section, priorityFilter));
+        isPromptInPriorityFilter(prompt.section, priorityFilter) &&
+        isPromptCompatibleWithRunner(prompt.file, prompt.section, promptRunnerIdentity));
 }
 
 /**
  * Selects the next runnable prompt based on priority.
  */
-function findNextTodoPrompt(files, priorityFilter = {}) {
+function findNextTodoPrompt(files, priorityFilter = {}, promptRunnerIdentity) {
     let nextPrompt;
-    for (const prompt of listRunnablePrompts(files, priorityFilter)) {
+    for (const prompt of listRunnablePrompts(files, priorityFilter, promptRunnerIdentity)) {
         if (!nextPrompt || prompt.section.priority > nextPrompt.section.priority) {
             nextPrompt = prompt;
         }
@@ -77078,8 +77672,8 @@ function findNextTodoPrompt(files, priorityFilter = {}) {
 /**
  * Lists upcoming tasks that are ready to run (no authoring placeholders).
  */
-function listUpcomingTasks(files, priorityFilter = {}) {
-    return listRunnablePrompts(files, priorityFilter).map(({ file, section }) => ({
+function listUpcomingTasks(files, priorityFilter = {}, promptRunnerIdentity) {
+    return listRunnablePrompts(files, priorityFilter, promptRunnerIdentity).map(({ file, section }) => ({
         label: buildPromptLabelForDisplay(file, section),
         summary: buildPromptSummary(file, section),
         priority: section.priority,
@@ -77223,6 +77817,71 @@ async function buildCoderRunAgentVisual(agentSource) {
     }
 }
 
+/**
+ * Creates the one queue prompt used to repair a pre-existing test failure.
+ */
+async function createTestBeforeRepairPrompt(options) {
+    const description = spaceTrim((block) => `
+            Fix the existing test failures before implementing any queued coding tasks.
+
+            The verification command \`${options.testCommand}\` failed before coding started. Fix the underlying failure without weakening or removing the tests, and leave the project ready for the remaining coding prompts.
+
+            ## Verification output
+
+            \`\`\`
+            ${block(limitTestOutput(options.testOutput))}
+            \`\`\`
+        `);
+    const createdPrompt = await addCoderPrompt({
+        projectPath: options.projectPath,
+        description,
+        priority: 0,
+    });
+    const promptPath = join(options.projectPath, createdPrompt.filePath);
+    const promptFile = parsePromptFile(promptPath, await readFile(promptPath, 'utf-8'));
+    const section = promptFile.sections[0];
+    if (!section) {
+        throw new UnexpectedError(spaceTrim(`
+                The pre-coding test repair prompt was created at \`${createdPrompt.filePath}\` without a runnable section.
+            `));
+    }
+    return { file: promptFile, section };
+}
+
+/**
+ * Runs the configured verification command before the first coding prompt.
+ */
+async function runTestBefore(options) {
+    var _a, _b;
+    const runPromptTestCommandExecutor = (_a = options.runPromptTestCommandExecutor) !== null && _a !== void 0 ? _a : runPromptTestCommand;
+    const initialTestStatusMessage = `Running initial tests before the agent coding starts: ${options.testCommand}`;
+    await ((_b = options.waitForPauseCheckpoint) === null || _b === void 0 ? void 0 : _b.call(options, {
+        checkpointLabel: 'running initial tests before the agent coding starts',
+        phase: 'verifying',
+        statusMessage: initialTestStatusMessage,
+    }));
+    console.info(colors.gray(initialTestStatusMessage));
+    try {
+        const testOutput = await runPromptTestCommandExecutor({
+            command: options.testCommand,
+            projectPath: options.projectPath,
+            scriptPath: buildTemporaryPromptScriptPath({
+                projectPath: options.projectPath,
+                scriptDirectoryName: 'coder-prompts',
+                sourceFileName: 'test-before',
+            }),
+        });
+        console.info(colors.green('Pre-coding tests passed.'));
+        return { isPassed: true, testOutput };
+    }
+    catch (error) {
+        const testOutput = formatUnknownErrorMessage(error);
+        console.error(colors.red('Pre-coding tests failed.'));
+        console.error(testOutput);
+        return { isPassed: false, testOutput };
+    }
+}
+
 /**
  * Constant for prompts dir.
  */
@@ -77250,6 +77909,10 @@ async function runCodexPrompts(providedOptions) {
             return;
         }
         const { runner, actualRunnerModel, runnerMetadata } = resolvePromptRunner(options);
+        const promptRunnerIdentity = {
+            harnessName: options.agentName,
+            modelName: actualRunnerModel,
+        };
         console.info(colors.green(`Running prompts with ${runner.name}`));
         initializeRunUi(uiHandle, runner.name, actualRunnerModel, options);
         await initializeRunUiAgentVisual(uiHandle, resolvedCoderAgent === null || resolvedCoderAgent === void 0 ? void 0 : resolvedCoderAgent.agentSource);
@@ -77264,6 +77927,7 @@ async function runCodexPrompts(providedOptions) {
         let previousRoundStartTime;
         let previousRoundEndTime;
         let completedRunCount = 0;
+        let hasRunTestBefore = false;
         while (just(true)) {
             if (options.autoPull && !options.dryRun) {
                 await waitForRequestedPause({
@@ -77276,6 +77940,35 @@ async function runCodexPrompts(providedOptions) {
                 options,
                 isRichUiEnabled,
             });
+            if (!hasRunTestBefore && options.testBefore !== 'no') {
+                await waitForRequestedPause({
+                    checkpointLabel: 'loading prompts before running initial tests',
+                    phase: 'loading',
+                    statusMessage: 'Loading prompts before running initial tests...',
+                });
+                await loadPromptQueueSnapshot({
+                    options,
+                    isRichUiEnabled,
+                    progressDisplay,
+                    uiHandle,
+                    promptRunnerIdentity,
+                });
+            }
+            if (!hasRunTestBefore) {
+                hasWaitedForStart = await runTestBeforeIfNeeded({
+                    options,
+                    runner,
+                    runnerMetadata,
+                    resolvedCoderContext,
+                    resolvedAgentSystemMessage,
+                    isRichUiEnabled,
+                    progressDisplay,
+                    uiHandle,
+                    waitForRequestedPause,
+                    hasWaitedForStart,
+                });
+                hasRunTestBefore = true;
+            }
             await waitForRequestedPause({
                 checkpointLabel: 'loading prompts',
                 phase: 'loading',
@@ -77286,6 +77979,7 @@ async function runCodexPrompts(providedOptions) {
                 isRichUiEnabled,
                 progressDisplay,
                 uiHandle,
+                promptRunnerIdentity,
             });
             hasShownUpcomingTasks || (hasShownUpcomingTasks = showUpcomingTasksOnce({
                 hasShownUpcomingTasks,
@@ -77293,6 +77987,7 @@ async function runCodexPrompts(providedOptions) {
                 stats: promptQueueSnapshot.stats,
                 priorityFilter: options.priorityFilter,
                 isRichUiEnabled,
+                promptRunnerIdentity,
             }));
             if (!promptQueueSnapshot.nextPrompt) {
                 if (isEndAfterCurrentPromptRequested(completedRunCount)) {
@@ -77395,6 +78090,14 @@ async function runCodexPrompts(providedOptions) {
  * Validates cross-flag constraints before the run starts.
  */
 function validateRunCodexPromptOptions(options) {
+    var _a;
+    if (!isTestBeforeMode((_a = options.testBefore) !== null && _a !== void 0 ? _a : 'no')) {
+        throw new NotAllowed(spaceTrim$1(`
+                Invalid ${'`--test-before`'} mode: \`${String(options.testBefore)}\`.
+
+                Use one of: \`no\`, \`yes-and-fail\`, \`yes-and-fix\`.
+            `));
+    }
     if (options.allowDestructiveAutoMigrate && !options.autoMigrate) {
         throw new DatabaseError(spaceTrim$1(`
                 Flag \`--allow-destructive-auto-migrate\` requires \`--auto-migrate\`.
@@ -77465,20 +78168,103 @@ function createRunDisplays(options, runStartDate) {
  * Normalizes legacy and current priority options into one validated run option shape.
  */
 function normalizeRunOptions(options) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g;
+    const testBefore = (_a = options.testBefore) !== null && _a !== void 0 ? _a : 'no';
+    const normalizedTestCommand = (_b = options.testCommand) === null || _b === void 0 ? void 0 : _b.trim();
     const priorityFilter = normalizePriorityFilter({
         priority: options.priority,
-        minimumPriority: (_a = options.minimumPriority) !== null && _a !== void 0 ? _a : (_b = options.priorityFilter) === null || _b === void 0 ? void 0 : _b.minimumPriority,
-        maximumPriority: (_c = options.maximumPriority) !== null && _c !== void 0 ? _c : (_d = options.priorityFilter) === null || _d === void 0 ? void 0 : _d.maximumPriority,
+        minimumPriority: (_c = options.minimumPriority) !== null && _c !== void 0 ? _c : (_d = options.priorityFilter) === null || _d === void 0 ? void 0 : _d.minimumPriority,
+        maximumPriority: (_e = options.maximumPriority) !== null && _e !== void 0 ? _e : (_f = options.priorityFilter) === null || _f === void 0 ? void 0 : _f.maximumPriority,
     });
     return {
         ...options,
-        priority: (_e = priorityFilter.minimumPriority) !== null && _e !== void 0 ? _e : 0,
+        testBefore,
+        testCommand: normalizedTestCommand || (testBefore === 'no' ? undefined : DEFAULT_CODER_TEST_COMMAND),
+        priority: (_g = priorityFilter.minimumPriority) !== null && _g !== void 0 ? _g : 0,
         minimumPriority: priorityFilter.minimumPriority,
         maximumPriority: priorityFilter.maximumPriority,
         priorityFilter,
     };
 }
+/**
+ * Runs the optional pre-coding verification and, when requested, its one repair prompt.
+ */
+async function runTestBeforeIfNeeded(options) {
+    const { options: runOptions, runner, runnerMetadata, resolvedCoderContext, resolvedAgentSystemMessage, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, hasWaitedForStart, } = options;
+    if (runOptions.testBefore === 'no') {
+        return hasWaitedForStart;
+    }
+    if (!runOptions.testCommand) {
+        throw new NotAllowed(spaceTrim$1(`
+                ${'`--test-before ' + runOptions.testBefore + '`'} requires a verification command.
+
+                Pass one with ${'`--test <test-command>`'} or use the default ${'`npm test`'} command by providing the mode through the CLI.
+            `));
+    }
+    if (!runOptions.ignoreGitChanges) {
+        await waitForRequestedPause({
+            checkpointLabel: 'checking the git working tree before testing',
+            phase: 'loading',
+            statusMessage: 'Checking the working tree before testing...',
+        });
+        await ensureWorkingTreeClean();
+    }
+    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.startCapturingAgentOutput();
+    const testBeforeResult = await runTestBefore({
+        testCommand: runOptions.testCommand,
+        projectPath: process.cwd(),
+        waitForPauseCheckpoint: waitForRequestedPause,
+    }).finally(() => {
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.stopCapturingAgentOutput();
+    });
+    if (testBeforeResult.isPassed) {
+        return hasWaitedForStart;
+    }
+    const testOutput = limitTestOutput(testBeforeResult.testOutput);
+    if (runOptions.testBefore === 'yes-and-fail') {
+        throw new NotAllowed(spaceTrim$1((block) => `
+                    Pre-coding verification command \`${runOptions.testCommand}\` failed.
+
+                    The coding agent was not started because the project was already failing before the first queued prompt.
+
+                    ### Test results
+                    ${'```'}
+                    ${block(testOutput)}
+                    ${'```'}
+                `));
+    }
+    const repairPrompt = await createTestBeforeRepairPrompt({
+        projectPath: process.cwd(),
+        testCommand: runOptions.testCommand,
+        testOutput,
+    });
+    const repairPromptLabel = buildPromptLabelForDisplay(repairPrompt.file, repairPrompt.section);
+    const updatedHasWaitedForStart = await waitForPromptConfirmationIfNeeded({
+        options: runOptions,
+        nextPrompt: repairPrompt,
+        promptLabel: repairPromptLabel,
+        hasWaitedForStart,
+        isRichUiEnabled,
+        progressDisplay,
+        uiHandle,
+    });
+    // The repair prompt is created in the current worktree so it can be recorded and committed with the repair.
+    // It therefore intentionally uses the regular round here even when the queue itself uses --isolate.
+    await runPromptRound({
+        options: runOptions,
+        runner,
+        runnerMetadata,
+        nextPrompt: repairPrompt,
+        promptLabel: repairPromptLabel,
+        resolvedCoderContext,
+        resolvedAgentSystemMessage,
+        isRichUiEnabled,
+        progressDisplay,
+        uiHandle,
+        waitForRequestedPause,
+    });
+    return updatedHasWaitedForStart;
+}
 /**
  * Creates a pause waiter that keeps the progress display and rich UI in sync.
  */
@@ -77563,7 +78349,7 @@ async function initializeRunUiAgentVisual(uiHandle, agentSource) {
  * Loads prompt files, updates progress displays, and selects the next runnable prompt.
  */
 async function loadPromptQueueSnapshot(options) {
-    const { options: runOptions, isRichUiEnabled, progressDisplay, uiHandle } = options;
+    const { options: runOptions, isRichUiEnabled, progressDisplay, uiHandle, promptRunnerIdentity } = options;
     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentScriptPath(undefined);
     const promptFiles = await loadPromptFiles(PROMPTS_DIR$1);
     const stats = summarizePrompts(promptFiles, runOptions.priorityFilter);
@@ -77575,14 +78361,14 @@ async function loadPromptQueueSnapshot(options) {
     return {
         promptFiles,
         stats,
-        nextPrompt: findNextTodoPrompt(promptFiles, runOptions.priorityFilter),
+        nextPrompt: findNextTodoPrompt(promptFiles, runOptions.priorityFilter, promptRunnerIdentity),
     };
 }
 /**
  * Prints upcoming tasks only on the first loop iteration in plain-console mode.
  */
 function showUpcomingTasksOnce(options) {
-    const { hasShownUpcomingTasks, promptFiles, stats, priorityFilter, isRichUiEnabled } = options;
+    const { hasShownUpcomingTasks, promptFiles, stats, priorityFilter, isRichUiEnabled, promptRunnerIdentity } = options;
     if (hasShownUpcomingTasks || isRichUiEnabled) {
         return true;
     }
@@ -77591,7 +78377,7 @@ function showUpcomingTasksOnce(options) {
         printPromptsToBeWritten(promptFiles, priorityFilter);
         console.info('');
     }
-    printUpcomingTasks(listUpcomingTasks(promptFiles, priorityFilter));
+    printUpcomingTasks(listUpcomingTasks(promptFiles, priorityFilter, promptRunnerIdentity));
     return true;
 }
 /**
@@ -77601,7 +78387,10 @@ function finishWhenNoPromptIsAvailable(promptQueueSnapshot, isRichUiEnabled, uiH
     if (promptQueueSnapshot.nextPrompt) {
         return false;
     }
-    if (promptQueueSnapshot.stats.toBeWritten > 0) {
+    if (promptQueueSnapshot.stats.forAgent > 0) {
+        announceRunCompletion('No prompts match the selected harness or model.', colors.yellow, isRichUiEnabled, uiHandle);
+    }
+    else if (promptQueueSnapshot.stats.toBeWritten > 0) {
         announceRunCompletion('No prompts ready for agent.', colors.yellow, isRichUiEnabled, uiHandle);
     }
     else {
@@ -77642,9 +78431,16 @@ function finishWhenEndAfterCurrentPromptIsRequested(options) {
  * Updates the UI status message while waiting for new prompts in keepAlive server mode.
  */
 function announceKeepAliveStatus(promptQueueSnapshot, isRichUiEnabled, uiHandle) {
-    const message = promptQueueSnapshot.stats.toBeWritten > 0
-        ? 'No prompts ready for agent. Watching for changes...'
-        : 'All prompts are done. Watching for changes...';
+    let message;
+    if (promptQueueSnapshot.stats.forAgent > 0) {
+        message = 'No prompts match the selected harness or model. Watching for changes...';
+    }
+    else if (promptQueueSnapshot.stats.toBeWritten > 0) {
+        message = 'No prompts ready for agent. Watching for changes...';
+    }
+    else {
+        message = 'All prompts are done. Watching for changes...';
+    }
     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(message);
     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('waiting');
     if (!isRichUiEnabled) {
@@ -77666,7 +78462,7 @@ function announceRunCompletion(message, colorize, isRichUiEnabled, uiHandle) {
  * Waits for the optional user confirmation before starting the selected prompt.
  */
 async function waitForPromptConfirmationIfNeeded(options) {
-    const { options: runOptions, nextPrompt, promptLabel, hasWaitedForStart, isRichUiEnabled, progressDisplay, uiHandle } = options;
+    const { options: runOptions, nextPrompt, promptLabel, hasWaitedForStart, isRichUiEnabled, progressDisplay, uiHandle, } = options;
     if (!runOptions.waitForUser) {
         return hasWaitedForStart;
     }
@@ -78988,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;
         }
@@ -79005,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.
  */
@@ -79016,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'),
+        },
     };
 }
 /**
@@ -79067,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,
     };
 }
 /**
@@ -79201,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;
@@ -79221,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',
@@ -79314,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',