@promptbook/cli 0.112.0-126 → 0.112.0-128

package/umd/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('commander'), require('spacetrim'), require('fs/promises'), require('path'), require('child_process'), require('crypto'), require('fs'), require('dotenv'), require('moment'), require('waitasecond'), require('prompts'), require('crypto-js/enc-hex'), require('crypto-js/sha256'), require('socket.io-client'), require('jszip'), require('@mozilla/readability'), require('jsdom'), require('crypto-js'), require('showdown'), require('glob-promise'), require('http'), require('express'), require('socket.io'), require('express-openapi-validator'), require('swagger-ui-express'), require('react'), require('react-dom/server'), require('@anthropic-ai/sdk'), require('bottleneck'), require('@azure/openai'), require('rxjs'), require('@openai/agents'), require('openai'), require('typescript'), require('ignore'), require('readline'), require('mime-types'), require('papaparse'), require('url'), require('events'), require('pg'), require('@supabase/supabase-js')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'commander', 'spacetrim', 'fs/promises', 'path', 'child_process', 'crypto', 'fs', 'dotenv', 'moment', 'waitasecond', 'prompts', 'crypto-js/enc-hex', 'crypto-js/sha256', 'socket.io-client', 'jszip', '@mozilla/readability', 'jsdom', 'crypto-js', 'showdown', 'glob-promise', 'http', 'express', 'socket.io', 'express-openapi-validator', 'swagger-ui-express', 'react', 'react-dom/server', '@anthropic-ai/sdk', 'bottleneck', '@azure/openai', 'rxjs', '@openai/agents', 'openai', 'typescript', 'ignore', 'readline', 'mime-types', 'papaparse', 'url', 'events', 'pg', '@supabase/supabase-js'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-cli"] = {}, global.colors, global.commander, global._spaceTrim, global.promises, global.path, global.child_process, global.crypto, global.fs, global.dotenv, global.moment, global.waitasecond, global.prompts, global.hexEncoder, global.sha256, global.socket_ioClient, global.JSZip, global.readability, global.jsdom, global.CryptoJS, global.showdown, global.glob, global.http, global.express, global.socket_io, global.OpenApiValidator, global.swaggerUi, global.react, global.server, global.Anthropic, global.Bottleneck, global.openai, global.rxjs, global.agents, global.OpenAI, global.ts, global.ignore, global.readline, global.mimeTypes, global.papaparse, global.url, global.events, global.pg));
-})(this, (function (exports, colors, commander, _spaceTrim, promises, path, child_process, crypto, fs, dotenv, moment, waitasecond, prompts, hexEncoder, sha256, socket_ioClient, JSZip, readability, jsdom, CryptoJS, showdown, glob, http, express, socket_io, OpenApiValidator, swaggerUi, react, server, Anthropic, Bottleneck, openai, rxjs, agents, OpenAI, ts, ignore, readline, mimeTypes, papaparse, url, events, pg) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('colors'), require('commander'), require('spacetrim'), require('fs/promises'), require('path'), require('child_process'), require('crypto'), require('fs'), require('dotenv'), require('moment'), require('waitasecond'), require('prompts'), require('crypto-js/enc-hex'), require('crypto-js/sha256'), require('socket.io-client'), require('jszip'), require('@mozilla/readability'), require('jsdom'), require('crypto-js'), require('showdown'), require('glob-promise'), require('http'), require('express'), require('socket.io'), require('express-openapi-validator'), require('swagger-ui-express'), require('react'), require('react-dom/server'), require('@anthropic-ai/sdk'), require('bottleneck'), require('@azure/openai'), require('rxjs'), require('@openai/agents'), require('openai'), require('typescript'), require('ignore'), require('readline'), require('events'), require('mime-types'), require('papaparse'), require('url'), require('pg'), require('@supabase/supabase-js')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'colors', 'commander', 'spacetrim', 'fs/promises', 'path', 'child_process', 'crypto', 'fs', 'dotenv', 'moment', 'waitasecond', 'prompts', 'crypto-js/enc-hex', 'crypto-js/sha256', 'socket.io-client', 'jszip', '@mozilla/readability', 'jsdom', 'crypto-js', 'showdown', 'glob-promise', 'http', 'express', 'socket.io', 'express-openapi-validator', 'swagger-ui-express', 'react', 'react-dom/server', '@anthropic-ai/sdk', 'bottleneck', '@azure/openai', 'rxjs', '@openai/agents', 'openai', 'typescript', 'ignore', 'readline', 'events', 'mime-types', 'papaparse', 'url', 'pg', '@supabase/supabase-js'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-cli"] = {}, global.colors, global.commander, global._spaceTrim, global.promises, global.path, global.child_process, global.crypto, global.fs, global.dotenv, global.moment, global.waitasecond, global.prompts, global.hexEncoder, global.sha256, global.socket_ioClient, global.JSZip, global.readability, global.jsdom, global.CryptoJS, global.showdown, global.glob, global.http, global.express, global.socket_io, global.OpenApiValidator, global.swaggerUi, global.react, global.server, global.Anthropic, global.Bottleneck, global.openai, global.rxjs, global.agents, global.OpenAI, global.ts, global.ignore, global.readline, global.events, global.mimeTypes, global.papaparse, global.url, global.pg));
+})(this, (function (exports, colors, commander, _spaceTrim, promises, path, child_process, crypto, fs, dotenv, moment, waitasecond, prompts, hexEncoder, sha256, socket_ioClient, JSZip, readability, jsdom, CryptoJS, showdown, glob, http, express, socket_io, OpenApiValidator, swaggerUi, react, server, Anthropic, Bottleneck, openai, rxjs, agents, OpenAI, ts, ignore, readline, events, mimeTypes, papaparse, url, pg) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -63,7 +63,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-126';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-128';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2697,8 +2697,16 @@
      * Builds a `.env` block containing missing Agents Server variables and documentation links.
      */
     function buildMissingEnvVariablesBlock$1(variables) {
-        const variableBlocks = variables.map(({ documentationUrl, name, value }) => [AGENTS_SERVER_ENV_CREATED_COMMENT, `# Documentation: ${documentationUrl}`, `${name}=${value}`].join('\n'));
-        return ['# Promptbook Agents Server', ...variableBlocks].join('\n\n');
+        const variableBlocks = variables.map(({ documentationUrl, name, value }) => _spaceTrim.spaceTrim(`
+            ${AGENTS_SERVER_ENV_CREATED_COMMENT}
+            # Documentation: ${documentationUrl}
+            ${name}=${value}
+        `));
+        return _spaceTrim.spaceTrim((block) => `
+            # Promptbook Agents Server
+
+            ${block(variableBlocks.join('\n\n'))}
+        `);
     }
     // Note: [🟡] Code for Agents Server environment bootstrapping [ensureAgentsServerEnvFile](src/cli/cli-commands/agents-server/ensureAgentsServerEnvFile.ts) should never be published outside of `@promptbook/cli`
 
@@ -4270,6 +4278,13 @@
             },
         ];
     }
+    /**
+     * Builds one OSC 8 terminal hyperlink to an HTTP URL.
+     */
+    function buildTerminalUrlLink(url, availableWidth) {
+        const displayUrl = fitPlainText(url, availableWidth);
+        return `\u001B]8;;${url}\u0007${displayUrl}\u001B]8;;\u0007`;
+    }
     /**
      * Builds the colored phase badge shown in the session box.
      */
@@ -4460,6 +4475,9 @@
         }
         const configurationRows = [
             ...buildOptionalSessionRow('Context', options.config.context),
+            ...buildOptionalSessionRow('Server', options.config.serverUrl
+                ? buildTerminalUrlLink(options.config.serverUrl, bodyWidth - SESSION_LABEL_WIDTH - 1)
+                : undefined),
             ...buildOptionalSessionRow('Test', options.config.testCommand),
         ];
         return [
@@ -4902,7 +4920,8 @@
      * @private internal entry point of coder run UI
      */
     function renderCoderRunUi(startTime, options = {}) {
-        const state = new CoderRunUiState(startTime);
+        var _a;
+        const state = (_a = options.state) !== null && _a !== void 0 ? _a : new CoderRunUiState(startTime);
         const buildFrameLinesFromState = options.buildFrameLines || buildCoderRunUiFrame;
         if (!process.stdout.isTTY) {
             return {
@@ -7881,8 +7900,11 @@
             if (!trimmedContent) {
                 return requirements;
             }
-            // Add goal as a proper h2 section to the system message
-            const goalSection = `## Goal\n\n${trimmedContent}`;
+            const goalSection = _spaceTrim.spaceTrim((block) => `
+                ## Goal
+
+                ${block(trimmedContent)}
+            `);
             const requirementsWithGoal = this.appendToSystemMessage(requirements, goalSection, '\n\n');
             return this.appendToPromptSuffix(requirementsWithGoal, trimmedContent);
         }
@@ -8404,8 +8426,11 @@
             if (!trimmedContent) {
                 return requirements;
             }
-            // Add language as a bullet under a ## Language section
-            const languageSection = `## Language\n\n-   Your language is ${trimmedContent}`;
+            const languageSection = _spaceTrim.spaceTrim((block) => `
+                ## Language
+
+                -   Your language is ${block(trimmedContent)}
+            `);
             return this.appendToSystemMessage(requirements, languageSection, '\n\n');
         }
     }
@@ -13370,41 +13395,91 @@
         context.fill();
         context.restore();
     }
+    /**
+     * Number of latitude segments used by the single blobby octopus mesh.
+     *
+     * @private helper of `octopus3d2AvatarVisual`
+     */
+    const LATITUDE_PATCH_COUNT$1 = 12;
+    /**
+     * Number of longitude segments used by the single blobby octopus mesh.
+     *
+     * @private helper of `octopus3d2AvatarVisual`
+     */
+    const LONGITUDE_PATCH_COUNT$1 = 24;
     /**
      * Resolves all visible projected patches for the single blobby octopus mesh.
      *
+     * Within a single frame, mesh corner samples and longitude-only lobe-wave values are
+     * quantized to the patch grid and computed once each rather than re-evaluated for every
+     * patch corner — the patch loop alone would call `sampleBlobbyOctopusSurfacePoint`
+     * `latitudePatchCount * longitudePatchCount * 4` times without caching, even though most
+     * corners are shared between neighboring patches.
+     *
      * @private helper of `octopus3d2AvatarVisual`
      */
     function resolveVisibleBlobbyOctopusPatches(options) {
         const { center, rotationX, rotationY, sceneCenterX, sceneCenterY, size, palette, morphologyProfile, animationPhase, timeMs, } = options;
-        const latitudePatchCount = 12;
-        const longitudePatchCount = 24;
+        const latitudePatchCount = LATITUDE_PATCH_COUNT$1;
+        const longitudePatchCount = LONGITUDE_PATCH_COUNT$1;
         const surfacePatches = [];
+        const latitudeBoundaries = new Float64Array(latitudePatchCount + 1);
+        const longitudeBoundaries = new Float64Array(longitudePatchCount + 1);
+        for (let boundaryIndex = 0; boundaryIndex <= latitudePatchCount; boundaryIndex++) {
+            latitudeBoundaries[boundaryIndex] = -Math.PI / 2 + (boundaryIndex / latitudePatchCount) * Math.PI;
+        }
+        for (let boundaryIndex = 0; boundaryIndex <= longitudePatchCount; boundaryIndex++) {
+            longitudeBoundaries[boundaryIndex] = -Math.PI + (boundaryIndex / longitudePatchCount) * Math.PI * 2;
+        }
+        const cachedLobeWavesByCornerLongitude = new Float64Array(longitudePatchCount + 1);
+        for (let boundaryIndex = 0; boundaryIndex <= longitudePatchCount; boundaryIndex++) {
+            cachedLobeWavesByCornerLongitude[boundaryIndex] = resolveLowerLobeWave(longitudeBoundaries[boundaryIndex], morphologyProfile, animationPhase, timeMs);
+        }
+        const cornerCount = (latitudePatchCount + 1) * (longitudePatchCount + 1);
+        const transformedCornerSamples = new Array(cornerCount);
+        for (let latitudeBoundaryIndex = 0; latitudeBoundaryIndex <= latitudePatchCount; latitudeBoundaryIndex++) {
+            const cornerLatitude = latitudeBoundaries[latitudeBoundaryIndex];
+            for (let longitudeBoundaryIndex = 0; longitudeBoundaryIndex <= longitudePatchCount; longitudeBoundaryIndex++) {
+                const cornerLongitude = longitudeBoundaries[longitudeBoundaryIndex];
+                const cornerIndex = latitudeBoundaryIndex * (longitudePatchCount + 1) + longitudeBoundaryIndex;
+                const cornerSample = sampleBlobbyOctopusSurfacePointWithLongitudeCache(options, cornerLatitude, cornerLongitude, cachedLobeWavesByCornerLongitude[longitudeBoundaryIndex]);
+                transformedCornerSamples[cornerIndex] = transformScenePoint(cornerSample, center, rotationX, rotationY);
+            }
+        }
         for (let latitudeIndex = 0; latitudeIndex < latitudePatchCount; latitudeIndex++) {
-            const startLatitude = -Math.PI / 2 + (latitudeIndex / latitudePatchCount) * Math.PI;
-            const endLatitude = -Math.PI / 2 + ((latitudeIndex + 1) / latitudePatchCount) * Math.PI;
+            const startLatitude = latitudeBoundaries[latitudeIndex];
+            const endLatitude = latitudeBoundaries[latitudeIndex + 1];
             const centerLatitude = (startLatitude + endLatitude) / 2;
             const verticalProgress = (Math.sin(centerLatitude) + 1) / 2;
+            const startCornerRowOffset = latitudeIndex * (longitudePatchCount + 1);
+            const endCornerRowOffset = (latitudeIndex + 1) * (longitudePatchCount + 1);
             for (let longitudeIndex = 0; longitudeIndex < longitudePatchCount; longitudeIndex++) {
-                const startLongitude = -Math.PI + (longitudeIndex / longitudePatchCount) * Math.PI * 2;
-                const endLongitude = -Math.PI + ((longitudeIndex + 1) / longitudePatchCount) * Math.PI * 2;
+                const startLongitude = longitudeBoundaries[longitudeIndex];
+                const endLongitude = longitudeBoundaries[longitudeIndex + 1];
                 const centerLongitude = (startLongitude + endLongitude) / 2;
-                const localCorners = [
-                    sampleBlobbyOctopusSurfacePoint(options, startLatitude, startLongitude),
-                    sampleBlobbyOctopusSurfacePoint(options, startLatitude, endLongitude),
-                    sampleBlobbyOctopusSurfacePoint(options, endLatitude, endLongitude),
-                    sampleBlobbyOctopusSurfacePoint(options, endLatitude, startLongitude),
+                const transformedCorners = [
+                    transformedCornerSamples[startCornerRowOffset + longitudeIndex],
+                    transformedCornerSamples[startCornerRowOffset + longitudeIndex + 1],
+                    transformedCornerSamples[endCornerRowOffset + longitudeIndex + 1],
+                    transformedCornerSamples[endCornerRowOffset + longitudeIndex],
                 ];
-                const transformedCorners = localCorners.map((localCorner) => transformScenePoint(localCorner, center, rotationX, rotationY));
                 const surfaceNormal = normalizeVector3(crossProduct3D(subtractPoint3D(transformedCorners[1], transformedCorners[0]), subtractPoint3D(transformedCorners[2], transformedCorners[0])));
                 if (surfaceNormal.z <= 0.01) {
                     continue;
                 }
-                const projectedCorners = transformedCorners.map((transformedCorner) => projectScenePoint(transformedCorner, size, sceneCenterX, sceneCenterY));
+                const projectedCorners = [
+                    projectScenePoint(transformedCorners[0], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[1], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[2], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[3], size, sceneCenterX, sceneCenterY),
+                ];
                 surfacePatches.push({
                     corners: projectedCorners,
-                    averageDepth: transformedCorners.reduce((depthSum, transformedCorner) => depthSum + transformedCorner.z, 0) /
-                        transformedCorners.length,
+                    averageDepth: (transformedCorners[0].z +
+                        transformedCorners[1].z +
+                        transformedCorners[2].z +
+                        transformedCorners[3].z) /
+                        4,
                     lightIntensity: clampNumber$1(dotProduct3D(surfaceNormal, LIGHT_DIRECTION$1), -1, 1),
                     fillStyle: resolveBlobbySurfacePatchFillStyle(palette, verticalProgress, Math.max(0, Math.cos(centerLongitude)), resolveLowerLobeWave(centerLongitude, morphologyProfile, animationPhase, timeMs)),
                     outlineColor: verticalProgress < 0.58 ? `${palette.highlight}73` : `${palette.shadow}8a`,
@@ -13422,12 +13497,21 @@
      * @private helper of `octopus3d2AvatarVisual`
      */
     function sampleBlobbyOctopusSurfacePoint(options, latitude, longitude) {
+        const { morphologyProfile, animationPhase, timeMs } = options;
+        return sampleBlobbyOctopusSurfacePointWithLongitudeCache(options, latitude, longitude, resolveLowerLobeWave(longitude, morphologyProfile, animationPhase, timeMs));
+    }
+    /**
+     * Samples one point on the continuous Octopus 3D 2 surface using a precomputed lower-lobe wave
+     * to skip the per-call trig evaluation for `latitudePatchCount + 1` longitude-shared corners.
+     *
+     * @private helper of `octopus3d2AvatarVisual`
+     */
+    function sampleBlobbyOctopusSurfacePointWithLongitudeCache(options, latitude, longitude, lowerLobeWave) {
         const { radiusX, radiusY, radiusZ, morphologyProfile, timeMs, animationPhase } = options;
         const cosineLatitude = Math.max(0, Math.cos(latitude));
         const verticalProgress = (Math.sin(latitude) + 1) / 2;
         const upperBlend = Math.pow(1 - verticalProgress, 1.2);
         const lowerBlend = Math.pow(verticalProgress, 1.42);
-        const lowerLobeWave = resolveLowerLobeWave(longitude, morphologyProfile, animationPhase, timeMs);
         const skirtEnvelope = Math.pow(cosineLatitude, 0.5) * lowerBlend;
         const horizontalScale = 1.02 +
             skirtEnvelope * (0.34 + (morphologyProfile.tentacles.rootSpreadScale - 1) * 0.22 + lowerLobeWave * 0.22) -
@@ -13724,45 +13808,102 @@
         context.fill();
         context.restore();
     }
+    /**
+     * Number of latitude segments used by the continuous Octopus 3D 3 mesh.
+     *
+     * @private helper of `octopus3d3AvatarVisual`
+     */
+    const LATITUDE_PATCH_COUNT = 16;
+    /**
+     * Number of longitude segments used by the continuous Octopus 3D 3 mesh.
+     *
+     * @private helper of `octopus3d3AvatarVisual`
+     */
+    const LONGITUDE_PATCH_COUNT = 40;
     /**
      * Resolves visible projected patches for the continuous octopus mesh.
      *
+     * Within a single frame, mesh corner samples and longitude-only computations (tentacle
+     * influence and lobe wave) are quantized to the patch grid and computed once each rather
+     * than re-evaluated for every patch corner — the patch loop alone calls `sampleContinuousOctopusSurfacePoint`
+     * for `latitudePatchCount * longitudePatchCount * 4` corners without caching, and each call
+     * triggers an inner 8-iteration `Math.exp` loop, which dominates the per-frame cost.
+     *
      * @private helper of `octopus3d3AvatarVisual`
      */
     function resolveVisibleContinuousOctopusPatches(options) {
         const { center, rotationX, rotationY, sceneCenterX, sceneCenterY, size, palette } = options;
-        const latitudePatchCount = 16;
-        const longitudePatchCount = 40;
+        const latitudePatchCount = LATITUDE_PATCH_COUNT;
+        const longitudePatchCount = LONGITUDE_PATCH_COUNT;
         const surfacePatches = [];
+        const latitudeBoundaries = new Float64Array(latitudePatchCount + 1);
+        const longitudeBoundaries = new Float64Array(longitudePatchCount + 1);
+        for (let boundaryIndex = 0; boundaryIndex <= latitudePatchCount; boundaryIndex++) {
+            latitudeBoundaries[boundaryIndex] = -Math.PI / 2 + (boundaryIndex / latitudePatchCount) * Math.PI;
+        }
+        for (let boundaryIndex = 0; boundaryIndex <= longitudePatchCount; boundaryIndex++) {
+            longitudeBoundaries[boundaryIndex] = -Math.PI + (boundaryIndex / longitudePatchCount) * Math.PI * 2;
+        }
+        const cachedTentacleInfluencesByCornerLongitude = new Array(longitudePatchCount + 1);
+        const cachedLobeWavesByCornerLongitude = new Float64Array(longitudePatchCount + 1);
+        const cachedTentacleInfluencesByPatchCenterLongitude = new Array(longitudePatchCount);
+        const cachedLobeWavesByPatchCenterLongitude = new Float64Array(longitudePatchCount);
+        const cachedCosByPatchCenterLongitude = new Float64Array(longitudePatchCount);
+        for (let boundaryIndex = 0; boundaryIndex <= longitudePatchCount; boundaryIndex++) {
+            const cornerLongitude = longitudeBoundaries[boundaryIndex];
+            cachedTentacleInfluencesByCornerLongitude[boundaryIndex] = resolveContinuousTentacleInfluence(options, cornerLongitude);
+            cachedLobeWavesByCornerLongitude[boundaryIndex] = resolveContinuousLobeWave(options, cornerLongitude);
+        }
+        for (let longitudeIndex = 0; longitudeIndex < longitudePatchCount; longitudeIndex++) {
+            const patchCenterLongitude = (longitudeBoundaries[longitudeIndex] + longitudeBoundaries[longitudeIndex + 1]) / 2;
+            cachedTentacleInfluencesByPatchCenterLongitude[longitudeIndex] = resolveContinuousTentacleInfluence(options, patchCenterLongitude);
+            cachedLobeWavesByPatchCenterLongitude[longitudeIndex] = resolveContinuousLobeWave(options, patchCenterLongitude);
+            cachedCosByPatchCenterLongitude[longitudeIndex] = Math.max(0, Math.cos(patchCenterLongitude));
+        }
+        const cornerCount = (latitudePatchCount + 1) * (longitudePatchCount + 1);
+        const transformedCornerSamples = new Array(cornerCount);
+        for (let latitudeBoundaryIndex = 0; latitudeBoundaryIndex <= latitudePatchCount; latitudeBoundaryIndex++) {
+            const cornerLatitude = latitudeBoundaries[latitudeBoundaryIndex];
+            for (let longitudeBoundaryIndex = 0; longitudeBoundaryIndex <= longitudePatchCount; longitudeBoundaryIndex++) {
+                const cornerLongitude = longitudeBoundaries[longitudeBoundaryIndex];
+                const cornerIndex = latitudeBoundaryIndex * (longitudePatchCount + 1) + longitudeBoundaryIndex;
+                const cornerSample = sampleContinuousOctopusSurfacePointWithLongitudeCache(options, cornerLatitude, cornerLongitude, cachedTentacleInfluencesByCornerLongitude[longitudeBoundaryIndex], cachedLobeWavesByCornerLongitude[longitudeBoundaryIndex]);
+                transformedCornerSamples[cornerIndex] = transformScenePoint(cornerSample, center, rotationX, rotationY);
+            }
+        }
         for (let latitudeIndex = 0; latitudeIndex < latitudePatchCount; latitudeIndex++) {
-            const startLatitude = -Math.PI / 2 + (latitudeIndex / latitudePatchCount) * Math.PI;
-            const endLatitude = -Math.PI / 2 + ((latitudeIndex + 1) / latitudePatchCount) * Math.PI;
+            const startLatitude = latitudeBoundaries[latitudeIndex];
+            const endLatitude = latitudeBoundaries[latitudeIndex + 1];
             const centerLatitude = (startLatitude + endLatitude) / 2;
             const verticalProgress = (Math.sin(centerLatitude) + 1) / 2;
+            const startCornerRowOffset = latitudeIndex * (longitudePatchCount + 1);
+            const endCornerRowOffset = (latitudeIndex + 1) * (longitudePatchCount + 1);
             for (let longitudeIndex = 0; longitudeIndex < longitudePatchCount; longitudeIndex++) {
-                const startLongitude = -Math.PI + (longitudeIndex / longitudePatchCount) * Math.PI * 2;
-                const endLongitude = -Math.PI + ((longitudeIndex + 1) / longitudePatchCount) * Math.PI * 2;
-                const centerLongitude = (startLongitude + endLongitude) / 2;
-                const localCorners = [
-                    sampleContinuousOctopusSurfacePoint(options, startLatitude, startLongitude),
-                    sampleContinuousOctopusSurfacePoint(options, startLatitude, endLongitude),
-                    sampleContinuousOctopusSurfacePoint(options, endLatitude, endLongitude),
-                    sampleContinuousOctopusSurfacePoint(options, endLatitude, startLongitude),
+                const transformedCorners = [
+                    transformedCornerSamples[startCornerRowOffset + longitudeIndex],
+                    transformedCornerSamples[startCornerRowOffset + longitudeIndex + 1],
+                    transformedCornerSamples[endCornerRowOffset + longitudeIndex + 1],
+                    transformedCornerSamples[endCornerRowOffset + longitudeIndex],
                 ];
-                const transformedCorners = localCorners.map((localCorner) => transformScenePoint(localCorner, center, rotationX, rotationY));
                 const surfaceNormal = normalizeVector3(crossProduct3D(subtractPoint3D(transformedCorners[1], transformedCorners[0]), subtractPoint3D(transformedCorners[2], transformedCorners[0])));
                 if (surfaceNormal.z <= 0.008) {
                     continue;
                 }
-                const projectedCorners = transformedCorners.map((transformedCorner) => projectScenePoint(transformedCorner, size, sceneCenterX, sceneCenterY));
-                const tentacleInfluence = resolveContinuousTentacleInfluence(options, centerLongitude);
-                const lowerLobeWave = resolveContinuousLobeWave(options, centerLongitude);
+                const projectedCorners = [
+                    projectScenePoint(transformedCorners[0], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[1], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[2], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[3], size, sceneCenterX, sceneCenterY),
+                ];
                 surfacePatches.push({
                     corners: projectedCorners,
-                    averageDepth: transformedCorners.reduce((depthSum, transformedCorner) => depthSum + transformedCorner.z, 0) /
-                        transformedCorners.length,
+                    averageDepth: (transformedCorners[0].z +
+                        transformedCorners[1].z +
+                        transformedCorners[2].z +
+                        transformedCorners[3].z) /
+                        4,
                     lightIntensity: clampNumber$1(dotProduct3D(surfaceNormal, LIGHT_DIRECTION), -1, 1),
-                    fillStyle: resolveContinuousSurfacePatchFillStyle(palette, verticalProgress, Math.max(0, Math.cos(centerLongitude)), tentacleInfluence.core, lowerLobeWave),
+                    fillStyle: resolveContinuousSurfacePatchFillStyle(palette, verticalProgress, cachedCosByPatchCenterLongitude[longitudeIndex], cachedTentacleInfluencesByPatchCenterLongitude[longitudeIndex].core, cachedLobeWavesByPatchCenterLongitude[longitudeIndex]),
                     outlineColor: verticalProgress < 0.54 ? `${palette.highlight}69` : `${palette.shadow}78`,
                 });
             }
@@ -13778,16 +13919,27 @@
      * @private helper of `octopus3d3AvatarVisual`
      */
     function sampleContinuousOctopusSurfacePoint(options, latitude, longitude) {
+        return sampleContinuousOctopusSurfacePointWithLongitudeCache(options, latitude, longitude, resolveContinuousTentacleInfluence(options, longitude), resolveContinuousLobeWave(options, longitude));
+    }
+    /**
+     * Samples one point on the continuous Octopus 3D 3 surface using precomputed longitude-only
+     * values to skip the per-call `Math.exp` tentacle-influence loop and the lobe-wave trig call.
+     *
+     * The patch loop quantizes the mesh into a fixed `(latitudePatchCount + 1) * (longitudePatchCount + 1)`
+     * corner grid, so the same longitude is reused across every latitude row and each
+     * tentacle/lobe value can be computed once per frame instead of `latitudePatchCount * 4` times.
+     *
+     * @private helper of `octopus3d3AvatarVisual`
+     */
+    function sampleContinuousOctopusSurfacePointWithLongitudeCache(options, latitude, longitude, tentacleInfluence, lowerLobeWave) {
         const { radiusX, radiusY, radiusZ, morphologyProfile, timeMs, animationPhase } = options;
         const cosineLatitude = Math.max(0, Math.cos(latitude));
         const verticalProgress = (Math.sin(latitude) + 1) / 2;
         const upperBlend = Math.pow(1 - verticalProgress, 1.28);
         const lowerBlend = smoothStep(0.38, 1, verticalProgress);
         const tipBlend = smoothStep(0.68, 1, verticalProgress);
-        const tentacleInfluence = resolveContinuousTentacleInfluence(options, longitude);
         const centerPull = resolveSignedAngularDistance(longitude, tentacleInfluence.centerLongitude);
         const effectiveLongitude = longitude + centerPull * lowerBlend * tentacleInfluence.core * (0.24 + tipBlend * 0.2);
-        const lowerLobeWave = resolveContinuousLobeWave(options, longitude);
         const mantleRipple = Math.sin(longitude * morphologyProfile.body.lobeCount +
             animationPhase * 0.6 +
             timeMs / (1750 + morphologyProfile.body.lobeCount * 30)) *
@@ -17192,7 +17344,15 @@
      * Builds the teammate request text, optionally including context.
      */
     function buildTeammateRequest(message, context) {
-        return context ? `${message}\n\nContext:\n${context}` : message;
+        if (!context) {
+            return message;
+        }
+        return _spaceTrim.spaceTrim((block) => `
+            ${block(message)}
+
+            Context:
+            ${block(context)}
+        `);
     }
     /**
      * Builds a minimal chat prompt for teammate calls.
@@ -21215,7 +21375,11 @@
                     const lineRangedContent = applyOptionalLineRange(decodedContent, args.startLine, args.endLine);
                     const wasCharacterTruncated = lineRangedContent.length > MAX_PROJECT_FILE_CONTENT_CHARACTERS;
                     const contentToReturn = wasCharacterTruncated
-                        ? `${lineRangedContent.slice(0, MAX_PROJECT_FILE_CONTENT_CHARACTERS)}\n\n[...truncated...]`
+                        ? _spaceTrim.spaceTrim((block) => `
+                              ${block(lineRangedContent.slice(0, MAX_PROJECT_FILE_CONTENT_CHARACTERS))}
+
+                              [...truncated...]
+                          `)
                         : lineRangedContent;
                     const wasTruncated = decoded.isTruncated || wasCharacterTruncated;
                     if (wasCharacterTruncated) {
@@ -26090,7 +26254,8 @@
     /**
      * Commits staged changes with the provided message using the dedicated coding-agent identity when configured,
      * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`,
-     * `options.includePaths` can restrict staging, and `options.excludePaths` can keep temporary artifacts out of the created commit.
+     * `options.includePaths` can restrict staging, `options.onlyPaths` can restrict the commit pathspec,
+     * and `options.excludePaths` can keep temporary artifacts out of the created commit.
      */
     async function commitChanges(message, options) {
         const projectPath = (options === null || options === void 0 ? void 0 : options.projectPath) || process.cwd();
@@ -26102,7 +26267,7 @@
             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 runGitCommand({
-                command: buildGitCommitCommand(commitMessagePath, signingFlag),
+                command: buildGitCommitCommand(commitMessagePath, signingFlag, options === null || options === void 0 ? void 0 : options.onlyPaths),
                 cwd: projectPath,
                 env: agentEnv,
             });
@@ -26282,12 +26447,15 @@
     /**
      * Builds the `git commit` command with an optional signing flag.
      */
-    function buildGitCommitCommand(commitMessagePath, signingFlag) {
+    function buildGitCommitCommand(commitMessagePath, signingFlag, onlyPaths) {
         const commandParts = ['git commit'];
         if (signingFlag) {
             commandParts.push(signingFlag);
         }
         commandParts.push(`--file "${commitMessagePath}"`);
+        if (onlyPaths && onlyPaths.length > 0) {
+            commandParts.push('--', ...onlyPaths.map(quoteShellPath$1));
+        }
         return commandParts.join(' ');
     }
     /**
@@ -27785,7 +27953,11 @@
         if (normalized.length <= OUTPUT_SNIPPET_MAX_CHARS) {
             return normalized;
         }
-        return `${normalized.slice(0, OUTPUT_SNIPPET_MAX_CHARS)}\n\n...[truncated]`;
+        return _spaceTrim.spaceTrim((block) => `
+            ${block(normalized.slice(0, OUTPUT_SNIPPET_MAX_CHARS))}
+
+            ...[truncated]
+        `);
     }
     /**
      * Builds one command failure message that keeps a useful snippet of CLI output.
@@ -27795,7 +27967,11 @@
         if (!outputSnippet) {
             return `Command "bash ${scriptPathPosix}" exited with code ${code !== null && code !== void 0 ? code : 'unknown'}`;
         }
-        return `Command "bash ${scriptPathPosix}" exited with code ${code !== null && code !== void 0 ? code : 'unknown'}\n\n${outputSnippet}`;
+        return _spaceTrim.spaceTrim((block) => `
+            Command "bash ${scriptPathPosix}" exited with code ${code !== null && code !== void 0 ? code : 'unknown'}
+
+            ${block(outputSnippet)}
+        `);
     }
     /**
      * Runs a script until a completion marker is observed and output is idle for a set timeout.
@@ -27912,7 +28088,9 @@
              * Handles process exit and resolves or rejects accordingly.
              */
             const handleExit = (code) => {
-                const failure = code === 0 || markerSeen ? undefined : new Error(buildCommandFailureMessage(scriptPathPosix, code, fullOutput));
+                const failure = code === 0 || markerSeen
+                    ? undefined
+                    : new Error(buildCommandFailureMessage(scriptPathPosix, code, fullOutput));
                 const status = failure ? `failed with exit code ${code !== null && code !== void 0 ? code : 'unknown'}` : 'succeeded';
                 settleWithLog(status, () => {
                     if (!failure) {
@@ -27930,8 +28108,14 @@
             });
             commandProcess.on('error', (error) => {
                 const outputSnippet = createOutputSnippet(fullOutput);
-                const details = outputSnippet ? `\n\n${outputSnippet}` : '';
-                const failure = new Error(`Command "bash ${scriptPathPosix}" failed: ${error.message}${details}`);
+                const failureMessage = outputSnippet
+                    ? _spaceTrim.spaceTrim((block) => `
+                          Command "bash ${scriptPathPosix}" failed: ${error.message}
+
+                          ${block(outputSnippet)}
+                      `)
+                    : `Command "bash ${scriptPathPosix}" failed: ${error.message}`;
+                const failure = new Error(failureMessage);
                 settleWithLog('failed before completion', () => reject(failure), failure);
             });
         });
@@ -28270,7 +28454,11 @@
         if (normalized.length <= maxChars) {
             return normalized;
         }
-        return `${normalized.slice(0, maxChars)}\n\n...[truncated]`;
+        return spaceTrim((block) => `
+            ${block(normalized.slice(0, maxChars))}
+
+            ...[truncated]
+        `);
     }
     /**
      * Returns true if at least one regex matches the provided text.
@@ -34919,11 +35107,19 @@
             try {
                 const json = JSON.parse(content);
                 const formattedJson = JSON.stringify(json, null, 4);
-                return `\`\`\`json\n${formattedJson}\n\`\`\``;
+                return _spaceTrim.spaceTrim((block) => `
+                    \`\`\`json
+                    ${block(formattedJson)}
+                    \`\`\`
+                `);
             }
             catch (error) {
                 // If JSON is invalid, still import it but maybe not as pretty JSON
-                return `\`\`\`json\n${content}\n\`\`\``;
+                return _spaceTrim.spaceTrim((block) => `
+                    \`\`\`json
+                    ${block(content)}
+                    \`\`\`
+                `);
             }
         },
     };
@@ -34947,7 +35143,11 @@
         import(content, mimeType) {
             const extension = mimeTypeToExtension(mimeType);
             const codeBlockType = extension || 'txt';
-            return `\`\`\`${codeBlockType}\n${content}\n\`\`\``;
+            return _spaceTrim.spaceTrim((block) => `
+                \`\`\`${codeBlockType}
+                ${block(content)}
+                \`\`\`
+            `);
         },
     };
 
@@ -35194,11 +35394,19 @@
         const examples = [];
         const initialMessage = (_a = parseResult.commitments.find((commitment) => commitment.type === 'INITIAL MESSAGE')) === null || _a === void 0 ? void 0 : _a.content;
         if (initialMessage) {
-            examples.push(`**Agent:**\n${initialMessage}`);
+            examples.push(_spaceTrim.spaceTrim((block) => `
+                    **Agent:**
+                    ${block(initialMessage)}
+                `));
         }
         if (samples && samples.length > 0) {
             for (const sample of samples) {
-                examples.push(`**User:** ${sample.question}\n\n**Agent:**\n${sample.answer}`);
+                examples.push(_spaceTrim.spaceTrim((block) => `
+                        **User:** ${block(String(sample.question))}
+
+                        **Agent:**
+                        ${block(sample.answer)}
+                    `));
             }
         }
         return examples;
@@ -35633,10 +35841,14 @@
      * Formats prepared model requirements for a text-only CLI harness prompt.
      */
     function formatAgentModelRequirementsForRunner(modelRequirements) {
+        const promptSuffix = modelRequirements.promptSuffix.trim();
         return [
             modelRequirements.systemMessage.trim(),
-            modelRequirements.promptSuffix.trim()
-                ? `## Prompt suffix\n${modelRequirements.promptSuffix.trim()}`
+            promptSuffix
+                ? _spaceTrim.spaceTrim((block) => `
+                      ## Prompt suffix
+                      ${block(promptSuffix)}
+                  `)
                 : '',
         ]
             .filter(Boolean)
@@ -39289,7 +39501,7 @@
      */
     const DEFAULT_CODER_PACKAGE_JSON_SCRIPTS = {
         'coder:generate-boilerplates': 'ptbk coder generate-boilerplates --template ./prompts/templates/common.md',
-        'coder:run': 'ptbk coder run --harness openai-codex --model gpt-5.4 --thinking-level xhigh --agent agents/developer.book --context AGENTS.md --no-wait',
+        'coder:run': 'ptbk coder run --harness openai-codex --model gpt-5.4 --thinking-level xhigh --agent agents/developer.book --context AGENTS.md',
         // 'coder:find-refactor-candidates': 'ptbk coder find-refactor-candidates',
         'coder:verify': 'ptbk coder verify',
     };
@@ -39748,33 +39960,26 @@
         command.option('--preserve-logs', 'Keep generated temp prompt/log artifacts after successful rounds for debugging and analytics', false);
         addPromptRunnerExecutionOptions(command);
         command.option('--priority <minimum-priority>', 'Filter prompts by minimum priority level', parseIntOption$1, 0);
-        command.option('--wait [duration]', _spaceTrim.spaceTrim(`
-            Wait between prompt rounds.
-            Without a value (default): waits for user confirmation before each prompt (interactive mode).
-            With a duration like 1h, 30m, 5s: waits that long between prompts to avoid hitting rate limits of the harness.
-        `), true);
-        // Note: --no-wait disables the default interactive wait-for-user behaviour
-        command.option('--no-wait', 'Skip all waiting between prompts and run non-interactively');
+        command.option('--wait <duration>', _spaceTrim.spaceTrim(`
+            Wait this long between prompt rounds to avoid hitting rate limits of the harness.
+            Accepts durations like 1h, 30m, 5s.
+        `));
+        // Note: --no-auto disables the default auto behaviour and waits for user confirmation before each prompt
+        command.option('--no-auto', 'Wait for user confirmation before each prompt instead of running automatically through the queue');
         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, priority, wait, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
+            const { dryRun, agent, context, test, preserveLogs, priority, wait, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
             const testCommand = normalizeCommandOptionValue$1(test);
             const runnerOptions = normalizePromptRunnerCliOptions(cliOptions, {
                 isAgentRequired: !dryRun,
             });
-            // [1] Parse the --wait option:
-            //   true (default or --wait without value): wait for user confirmation
-            //   false (--no-wait): no waiting at all
-            //   string (--wait 1h): wait that long between prompt rounds
-            let waitForUser = false;
-            let waitBetweenPrompts = 0;
-            if (wait === true) {
-                waitForUser = true;
-            }
-            else if (typeof wait === 'string' && wait !== '') {
-                waitBetweenPrompts = parseDuration(wait);
-            }
+            // [1] Parse the --wait and --no-auto options:
+            //   default: run automatically through the queue (no waiting)
+            //   --no-auto: wait for user confirmation before each prompt (interactive mode)
+            //   --wait <duration>: wait that long between prompt rounds to avoid rate limits
+            const waitForUser = !auto;
+            const waitBetweenPrompts = typeof wait === 'string' && wait !== '' ? parseDuration(wait) : 0;
             // Convert commander options to RunOptions format
             const runOptions = {
                 dryRun,
@@ -39887,30 +40092,23 @@
         command.option('--preserve-logs', 'Keep generated temp prompt/log artifacts after successful rounds for debugging and analytics', false);
         addPromptRunnerExecutionOptions(command);
         command.option('--priority <minimum-priority>', 'Filter prompts by minimum priority level', parseIntOption, 0);
-        command.option('--wait [duration]', _spaceTrim.spaceTrim(`
-            Wait between prompt rounds.
-            Without a value (default): waits for user confirmation before each prompt (interactive mode).
-            With a duration like 1h, 30m, 5s: waits that long between prompts to avoid hitting rate limits of the harness.
-        `), true);
-        command.option('--no-wait', 'Skip all waiting between prompts and run non-interactively');
+        command.option('--wait <duration>', _spaceTrim.spaceTrim(`
+            Wait this long between prompt rounds to avoid hitting rate limits of the harness.
+            Accepts durations like 1h, 30m, 5s.
+        `));
+        command.option('--no-auto', 'Wait for user confirmation before each prompt instead of running automatically through the queue');
         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 { port: rawPort, dryRun, agent, context, test, preserveLogs, priority, wait, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
+            const { port: rawPort, dryRun, agent, context, test, preserveLogs, priority, wait, auto, autoMigrate, allowDestructiveAutoMigrate, } = cliOptions;
             const port = parseCoderServerPort(rawPort);
             const testCommand = normalizeCommandOptionValue(test);
             const runnerOptions = normalizePromptRunnerCliOptions(cliOptions, {
                 isAgentRequired: !dryRun,
             });
-            // [1] Parse the --wait option (same logic as `coder run`)
-            let waitForUser = false;
-            let waitBetweenPrompts = 0;
-            if (wait === true) {
-                waitForUser = true;
-            }
-            else if (typeof wait === 'string' && wait !== '') {
-                waitBetweenPrompts = parseDuration(wait);
-            }
+            // [1] Parse the --wait and --no-auto options (same logic as `coder run`)
+            const waitForUser = !auto;
+            const waitBetweenPrompts = typeof wait === 'string' && wait !== '' ? parseDuration(wait) : 0;
             const runOptions = {
                 port,
                 dryRun,
@@ -40516,7 +40714,12 @@
      * @private internal function of `$registeredLlmToolsMessage`
      */
     function createUsedEnvMessage() {
-        return $usedEnvFilename === null ? `Unknown \`.env\` file` : `Used \`.env\` file:\n${$usedEnvFilename}`;
+        return $usedEnvFilename === null
+            ? `Unknown \`.env\` file`
+            : _spaceTrim.spaceTrim(`
+              Used \`.env\` file:
+              ${$usedEnvFilename}
+          `);
     }
     // TODO: [®] DRY Register logic
     // TODO: [🧠][⚛] Maybe pass env as argument
@@ -53106,7 +53309,11 @@
      * @private utility of CLI
      */
     function $deprecateCliCommand(command, deprecationMessage) {
-        command.description(`${command.description()}\n\nDeprecated: ${deprecationMessage}`);
+        command.description(_spaceTrim.spaceTrim((block) => `
+                ${block(command.description())}
+
+                Deprecated: ${block(deprecationMessage)}
+            `));
         command.hook('preAction', () => {
             console.warn(colors__default["default"].yellow(createDeprecatedCliCommandWarning(command, deprecationMessage)));
         });
@@ -65915,7 +66122,11 @@
             };
         }
         return {
-            content: `${content.slice(0, Math.max(0, maxCharacters))}\n\n[...truncated...]`,
+            content: _spaceTrim.spaceTrim((block) => `
+                ${block(content.slice(0, Math.max(0, maxCharacters)))}
+
+                [...truncated...]
+            `),
             isTruncated: true,
         };
     }
@@ -69215,7 +69426,7 @@
     /**
      * CLI usage text for this script.
      */
-    const USAGE = 'Usage: run-codex-prompts [--dry-run] [--harness <harness-name>] [--model <model>] [--context <context-or-file>] [--test <test-command...>] [--preserve-logs] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--wait [duration]] [--no-wait] [--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...>] [--preserve-logs] [--no-ui] [--thinking-level <thinking-level>] [--priority <minimum-priority>] [--allow-credits] [--auto-migrate] [--allow-destructive-auto-migrate] [--wait <duration>] [--no-auto] [--no-commit] [--ignore-git-changes] [--no-normalize-line-endings] [--auto-push] [--auto-pull]';
     /**
      * Top-level flags supported by this command.
      */
@@ -69233,7 +69444,7 @@
         '--auto-migrate',
         '--allow-destructive-auto-migrate',
         '--wait',
-        '--no-wait',
+        '--no-auto',
         '--no-commit',
         '--ignore-git-changes',
         '--no-normalize-line-endings',
@@ -69271,22 +69482,20 @@
         const allowDestructiveAutoMigrate = args.includes('--allow-destructive-auto-migrate');
         const autoPush = args.includes('--auto-push');
         const autoPull = args.includes('--auto-pull');
-        // [1] Parse --wait [duration]:
-        //   absent or --no-wait: no waiting
-        //   --wait (no value): wait for user confirmation
+        // [1] Parse --wait <duration> and --no-auto:
+        //   default: run automatically through the queue (no waiting)
+        //   --no-auto: wait for user confirmation before each prompt (interactive mode)
         //   --wait 1h: wait 1h between prompt rounds to avoid rate limits
-        const waitOptionalValue = readOptionalOptionValue(args, '--wait');
-        let waitForUser = false;
+        const waitForUser = args.includes('--no-auto');
         let waitBetweenPrompts = 0;
-        if (waitOptionalValue === null) {
-            // --wait present without a duration value: interactive mode
-            waitForUser = true;
-        }
-        else if (waitOptionalValue !== undefined) {
-            // --wait <duration>: time-based wait between rounds
-            waitBetweenPrompts = parseDuration(waitOptionalValue);
+        const hasWaitFlag = args.includes('--wait');
+        const waitValue = readOptionValue(args, '--wait');
+        if (hasWaitFlag) {
+            if (waitValue === undefined || waitValue.startsWith('-')) {
+                exitWithUsageError('Missing value for --wait. Use a duration like 1h, 30m, 5s.');
+            }
+            waitBetweenPrompts = parseDuration(waitValue);
         }
-        // --no-wait (or no flag): both waitForUser and waitBetweenPrompts remain false/0
         let thinkingLevel;
         if (hasTestCommandFlag && testCommand === undefined) {
             exitWithUsageError('Missing value for --test. Use a shell command such as `npm run test` and quote it when it contains top-level CLI flags.');
@@ -69325,23 +69534,6 @@
             priority,
         };
     }
-    /**
-     * Reads an optional value for a flag that may appear with or without a following value.
-     *
-     * Returns `undefined` when the flag is absent, `null` when the flag is present but has no value
-     * (the next token is another flag or the end of args), and the value string otherwise.
-     */
-    function readOptionalOptionValue(args, flag) {
-        if (!args.includes(flag)) {
-            return undefined;
-        }
-        const index = args.indexOf(flag);
-        const nextArg = args[index + 1];
-        if (nextArg === undefined || nextArg.startsWith('-')) {
-            return null;
-        }
-        return nextArg;
-    }
     /**
      * Reads a value of a CLI option that follows a given flag.
      */
@@ -71318,7 +71510,13 @@
         const taskPrompt = buildCodexPrompt(nextPrompt.file, nextPrompt.section);
         // Prepend agent system message before the task so the harness sees agent instructions first
         const promptWithAgent = resolvedAgentSystemMessage
-            ? `${resolvedAgentSystemMessage.trim()}\n\n${taskPrompt}`
+            ? _spaceTrim.spaceTrim((block) => `
+                  ${block(resolvedAgentSystemMessage.trim())}
+
+                  ## Your Task
+
+                  ${block(taskPrompt)}
+              `)
             : taskPrompt;
         const codexPrompt = appendCoderContext(promptWithAgent, resolvedCoderContext);
         const scriptPath = buildScriptPath(nextPrompt.file, nextPrompt.section);
@@ -71387,11 +71585,11 @@
      */
     function setPromptRoundRunningState(options) {
         const { isRichUiEnabled, promptLabel, scriptPath, uiHandle } = options;
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentPrompt(promptLabel);
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentScriptPath(scriptPath);
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('running');
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Running');
         if (isRichUiEnabled) {
-            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentPrompt(promptLabel);
-            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentScriptPath(scriptPath);
-            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('running');
-            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Running');
             return;
         }
         console.info(colors__default["default"].blue(`Processing ${promptLabel}`));
@@ -71661,7 +71859,7 @@
         }
         if (options.noCommit && !options.waitForUser && !options.ignoreGitChanges) {
             throw new NotAllowed(_spaceTrim.spaceTrim(`
-                Flag \`--no-commit\` requires \`--ignore-git-changes\` when combined with \`--no-wait\`.
+                Flag \`--no-commit\` requires \`--ignore-git-changes\` when running in auto mode (the default; pass \`--no-auto\` for interactive confirmation).
 
                 Without commits, the next prompt round would fail the clean working tree check.
             `));
@@ -71693,7 +71891,11 @@
     function createRunDisplays(options, runStartDate) {
         const isRichUiEnabled = !options.dryRun && !options.noUi && Boolean(process.stdout.isTTY);
         const progressDisplay = options.dryRun || options.noUi || isRichUiEnabled ? undefined : new CliProgressDisplay(runStartDate, options.priority);
-        const uiHandle = isRichUiEnabled ? renderCoderRunUi(runStartDate) : undefined;
+        const uiHandle = isRichUiEnabled || options.uiState
+            ? renderCoderRunUi(runStartDate, {
+                state: options.uiState,
+            })
+            : undefined;
         return {
             isRichUiEnabled,
             progressDisplay,
@@ -71758,6 +71960,7 @@
             modelName: actualRunnerModel,
             thinkingLevel: options.thinkingLevel,
             context: options.context,
+            serverUrl: options.serverUrl,
             priority: options.priority,
             testCommand: options.testCommand,
         });
@@ -71916,6 +72119,166 @@
         runCodexPrompts: runCodexPrompts
     });
 
+    /**
+     * Converts parsed prompt files into a web-board response with derived columns and tags.
+     */
+    function buildCoderServerPromptFileResponses(options) {
+        const activePrompt = getActivePrompt(options.uiState);
+        return [
+            ...options.promptFiles.map((promptFile) => buildCoderServerPromptFileResponse({
+                promptFile,
+                isFinished: false,
+                minimumPriority: options.minimumPriority,
+                activePrompt,
+            })),
+            ...options.finishedPromptFiles.map((promptFile) => buildCoderServerPromptFileResponse({
+                promptFile,
+                isFinished: true,
+                minimumPriority: options.minimumPriority,
+                activePrompt,
+            })),
+        ];
+    }
+    /**
+     * Builds one prompt-file response.
+     */
+    function buildCoderServerPromptFileResponse(options) {
+        const { promptFile, isFinished, minimumPriority, activePrompt } = options;
+        return {
+            filePath: promptFile.path,
+            fileName: promptFile.name,
+            relativeFilePath: path.relative(process.cwd(), promptFile.path).replace(/\\/gu, '/'),
+            isFinished,
+            sections: promptFile.sections.map((section) => buildCoderServerPromptSectionResponse({
+                promptFile,
+                section,
+                isFinished,
+                minimumPriority,
+                activePrompt,
+            })),
+        };
+    }
+    /**
+     * Builds one prompt-section response with derived board metadata.
+     */
+    function buildCoderServerPromptSectionResponse(options) {
+        const { promptFile, section, isFinished, minimumPriority, activePrompt } = options;
+        const isUnwritten = isPromptToBeWritten(promptFile, section);
+        const isActive = isPromptActive(promptFile, section, activePrompt);
+        const column = getPromptColumn({
+            section,
+            isFinished,
+            isUnwritten,
+            isActive,
+            minimumPriority,
+        });
+        return {
+            index: section.index,
+            status: section.status,
+            column,
+            priority: section.priority,
+            summary: buildPromptSummary(promptFile, section),
+            content: buildCodexPrompt(promptFile, section),
+            label: buildPromptLabelForDisplay(promptFile, section),
+            tags: buildPromptTags({
+                section,
+                isUnwritten,
+                isActive,
+                activePrompt,
+            }),
+        };
+    }
+    /**
+     * Chooses the web-board column for one prompt section without changing persisted prompt status.
+     */
+    function getPromptColumn(options) {
+        const { section, isFinished, isUnwritten, isActive, minimumPriority } = options;
+        if (isFinished) {
+            return 'finished';
+        }
+        if (section.status === 'failed') {
+            return 'errors';
+        }
+        if (section.status === 'done') {
+            return 'done';
+        }
+        if (section.status === 'not-ready' || isUnwritten) {
+            return 'backlog';
+        }
+        if (isActive) {
+            return 'in-progress';
+        }
+        if (!hasSufficientPriority(section, minimumPriority)) {
+            return 'low-priority';
+        }
+        return 'todo';
+    }
+    /**
+     * Builds all tags shown on a prompt card.
+     */
+    function buildPromptTags(options) {
+        var _a;
+        const tags = [];
+        if (options.section.status === 'not-ready') {
+            tags.push({ id: 'not-ready', label: '[-]' });
+        }
+        if (options.isUnwritten) {
+            tags.push({ id: 'unwritten', label: '@@@' });
+        }
+        if (options.isActive) {
+            tags.push(((_a = options.activePrompt) === null || _a === void 0 ? void 0 : _a.phase) === 'verifying'
+                ? { id: 'verifying', label: 'Verifying' }
+                : { id: 'implementing', label: 'Implementing' });
+        }
+        return tags;
+    }
+    /**
+     * Extracts an active prompt only while an agent is implementing or verifying it.
+     */
+    function getActivePrompt(uiState) {
+        if (!(uiState === null || uiState === void 0 ? void 0 : uiState.currentPromptLabel)) {
+            return undefined;
+        }
+        if (uiState.phase !== 'running' && uiState.phase !== 'verifying') {
+            return undefined;
+        }
+        return {
+            label: uiState.currentPromptLabel,
+            phase: uiState.phase,
+        };
+    }
+    /**
+     * Checks whether a parsed section is the prompt currently handled by the active agent.
+     */
+    function isPromptActive(promptFile, section, activePrompt) {
+        if (!activePrompt || section.status !== 'todo') {
+            return false;
+        }
+        return buildPromptLabelForDisplay(promptFile, section) === activePrompt.label;
+    }
+    // Note: [🟡] Code for CLI command [coder server](scripts/run-codex-prompts/server/buildCoderServerPromptResponse.ts) should never be published outside of `@promptbook/cli`
+
+    /**
+     * Builds a plain JSON-safe snapshot from the shared terminal UI state.
+     */
+    function buildCoderServerRunState(uiState) {
+        return {
+            config: uiState.config,
+            phase: uiState.phase,
+            currentPromptLabel: uiState.currentPromptLabel,
+            currentAttempt: uiState.currentAttempt,
+            maxAttempts: uiState.maxAttempts,
+            statusMessage: uiState.statusMessage,
+            detailLines: [...uiState.detailLines],
+            agentStatusLines: [...uiState.agentStatusLines],
+            agentStatusTableRows: [...uiState.agentStatusTableRows],
+            agentOutputLines: [...uiState.agentOutputLines],
+            errors: [...uiState.errors],
+            progress: uiState.getProgress(),
+        };
+    }
+    // Note: [🟡] Code for CLI command [coder server](scripts/run-codex-prompts/server/buildCoderServerRunState.ts) should never be published outside of `@promptbook/cli`
+
     /**
      * Overwrites the body of one prompt section with new content, preserving the status line.
      *
@@ -71928,9 +72291,14 @@
         var _a;
         const rawContent = await promises.readFile(filePath, 'utf-8');
         const promptFile = parsePromptFile(filePath, rawContent);
-        const section = promptFile.sections.find((s) => s.index === sectionIndex);
+        const section = promptFile.sections.find((sectionCandidate) => sectionCandidate.index === sectionIndex);
         if (!section) {
-            throw new Error(`Section ${sectionIndex} not found in file: ${filePath}`);
+            throw new NotFoundError(_spaceTrim.spaceTrim(`
+                Prompt section \`${sectionIndex}\` was not found.
+
+                File:
+                \`${filePath}\`
+            `));
         }
         // Lines before the status line (usually empty lines at section start)
         const linesBeforeStatus = section.statusLineIndex !== undefined
@@ -71957,7 +72325,11 @@
             ...promptFile.lines.slice(section.endLine + 1),
         ];
         const updatedContent = updatedLines.join(promptFile.eol) + (promptFile.hasFinalEol ? promptFile.eol : '');
+        if (updatedContent === rawContent) {
+            return false;
+        }
         await promises.writeFile(filePath, updatedContent, 'utf-8');
+        return true;
     }
     // Note: [🟡] Code for CLI command [coder server](scripts/run-codex-prompts/server/updatePromptSection.ts) should never be published outside of `@promptbook/cli`
 
@@ -71978,38 +72350,37 @@
   <style>
     * { box-sizing: border-box; margin: 0; padding: 0; }
     body {
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-      background: #f4f5f7;
-      color: #172b4d;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: #f6f7f9;
+      color: #1f2933;
       min-height: 100vh;
     }
 
     header {
-      background: #0052cc;
+      background: #22313f;
       color: white;
-      padding: 12px 20px;
+      padding: 12px 18px;
       display: flex;
       align-items: center;
       gap: 12px;
       position: sticky;
       top: 0;
       z-index: 10;
-      box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+      box-shadow: 0 2px 10px rgba(15,23,42,0.22);
     }
-    header h1 { font-size: 17px; font-weight: 700; flex-shrink: 0; }
+    header h1 { font-size: 17px; font-weight: 700; flex-shrink: 0; letter-spacing: 0; }
 
     .status-badge {
       padding: 3px 10px;
-      border-radius: 12px;
+      border-radius: 999px;
       font-size: 11px;
       font-weight: 700;
-      letter-spacing: 0.5px;
       text-transform: uppercase;
       flex-shrink: 0;
     }
-    .status-RUNNING  { background: #00875a; color: white; }
-    .status-PAUSING  { background: #ff8b00; color: white; }
-    .status-PAUSED   { background: #bf2600; color: white; }
+    .status-RUNNING { background: #0b875b; color: white; }
+    .status-PAUSING { background: #d97904; color: white; }
+    .status-PAUSED { background: #b42318; color: white; }
 
     #pause-label {
       font-size: 12px;
@@ -72022,57 +72393,122 @@
     }
 
     .btn {
-      padding: 6px 14px;
-      border: none;
+      padding: 6px 12px;
+      border: 0;
       border-radius: 4px;
       cursor: pointer;
       font-size: 13px;
-      font-weight: 600;
-      transition: opacity 0.15s;
+      font-weight: 700;
+      transition: background 0.15s, opacity 0.15s;
       flex-shrink: 0;
     }
-    .btn:hover { opacity: 0.85; }
-    .btn-pause  { background: #ffc400; color: #172b4d; }
-    .btn-resume { background: #00875a; color: white; }
+    .btn:disabled { opacity: 0.55; cursor: default; }
+    .btn-pause { background: #ffd166; color: #1f2933; }
+    .btn-resume { background: #0b875b; color: white; }
+    .btn-save { background: #2563eb; color: white; }
+    .btn-cancel { background: #edf0f4; color: #1f2933; }
+
+    .run-strip {
+      background: white;
+      border-bottom: 1px solid #d8dee8;
+      padding: 12px 18px;
+      display: grid;
+      grid-template-columns: minmax(220px, 1.2fr) minmax(240px, 1fr) minmax(260px, 1.4fr);
+      gap: 14px;
+      align-items: center;
+    }
+    .run-title {
+      font-size: 14px;
+      font-weight: 700;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .run-subtitle,
+    .run-current,
+    .run-output {
+      color: #64748b;
+      font-size: 12px;
+      line-height: 1.45;
+      overflow: hidden;
+    }
+    .run-current,
+    .run-output {
+      display: -webkit-box;
+      -webkit-box-orient: vertical;
+      -webkit-line-clamp: 2;
+    }
+    .progress-shell {
+      display: grid;
+      grid-template-columns: 1fr auto;
+      gap: 8px;
+      align-items: center;
+    }
+    .progress-track {
+      height: 10px;
+      background: #e4e9f0;
+      border-radius: 999px;
+      overflow: hidden;
+    }
+    .progress-fill {
+      display: block;
+      height: 100%;
+      width: 0;
+      background: linear-gradient(90deg, #0b875b, #2563eb);
+      transition: width 0.2s;
+    }
+    .progress-label {
+      color: #475569;
+      font-size: 12px;
+      font-weight: 700;
+      min-width: 72px;
+      text-align: right;
+    }
 
     .board {
       display: flex;
       gap: 14px;
       padding: 16px;
       overflow-x: auto;
-      min-height: calc(100vh - 52px);
+      min-height: calc(100vh - 119px);
       align-items: flex-start;
     }
 
     .column {
-      background: #ebecf0;
-      border-radius: 8px;
+      background: #e9edf3;
+      border-top: 4px solid #94a3b8;
+      border-radius: 6px;
       padding: 10px;
       min-width: 250px;
       width: 270px;
       flex-shrink: 0;
     }
+    .column-backlog { border-top-color: #64748b; }
+    .column-low-priority { border-top-color: #d97904; }
+    .column-todo { border-top-color: #2563eb; }
+    .column-in-progress { border-top-color: #7c3aed; }
+    .column-done { border-top-color: #0b875b; }
+    .column-errors { border-top-color: #b42318; }
+    .column-finished { border-top-color: #0891b2; }
 
     .column-header {
       font-size: 12px;
-      font-weight: 700;
+      font-weight: 800;
       text-transform: uppercase;
-      letter-spacing: 0.6px;
-      color: #5e6c84;
+      color: #475569;
       margin-bottom: 10px;
       display: flex;
       align-items: center;
       justify-content: space-between;
+      gap: 8px;
     }
-
     .column-count {
-      background: #dfe1e6;
-      border-radius: 10px;
-      padding: 1px 7px;
+      background: rgba(255,255,255,0.72);
+      border-radius: 999px;
+      padding: 2px 8px;
       font-size: 11px;
-      color: #5e6c84;
+      color: #475569;
     }
-
     .column-cards { min-height: 40px; }
 
     .card {
@@ -72080,57 +72516,61 @@
       border-radius: 6px;
       padding: 10px 12px;
       margin-bottom: 8px;
-      box-shadow: 0 1px 3px rgba(0,0,0,0.08);
+      box-shadow: 0 1px 3px rgba(15,23,42,0.12);
       cursor: pointer;
-      transition: box-shadow 0.15s, transform 0.1s;
-      border-left: 3px solid transparent;
-    }
-    .card:hover {
-      box-shadow: 0 4px 10px rgba(0,0,0,0.14);
-      transform: translateY(-1px);
+      border-left: 3px solid #94a3b8;
     }
-    .card-todo      { border-left-color: #0052cc; }
-    .card-not-ready { border-left-color: #8993a4; }
-    .card-done      { border-left-color: #00875a; }
-    .card-failed    { border-left-color: #bf2600; }
+    .card:hover { box-shadow: 0 4px 12px rgba(15,23,42,0.16); }
+    .card-backlog { border-left-color: #64748b; }
+    .card-low-priority { border-left-color: #d97904; }
+    .card-todo { border-left-color: #2563eb; }
+    .card-in-progress { border-left-color: #7c3aed; }
+    .card-done { border-left-color: #0b875b; }
+    .card-errors { border-left-color: #b42318; }
+    .card-finished { border-left-color: #0891b2; }
 
     .card-file {
       font-size: 10px;
-      color: #8993a4;
-      margin-bottom: 5px;
-      font-weight: 500;
+      color: #7b8794;
+      margin-bottom: 6px;
+      font-weight: 600;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
     }
-
     .card-summary {
       font-size: 13px;
-      line-height: 1.5;
-      color: #172b4d;
+      line-height: 1.45;
+      color: #1f2933;
       word-break: break-word;
       white-space: pre-wrap;
-      max-height: 78px;
+      max-height: 76px;
       overflow: hidden;
       display: -webkit-box;
       -webkit-line-clamp: 4;
       -webkit-box-orient: vertical;
     }
-
-    .card-priority {
-      margin-top: 6px;
-      color: #ff8b00;
-      font-size: 11px;
-      font-weight: 700;
+    .card-tags {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 5px;
+      margin-top: 8px;
     }
-
-    .card-edit-hint {
+    .card-tag {
+      border-radius: 999px;
+      padding: 2px 7px;
       font-size: 10px;
-      color: #c1c7d0;
-      margin-top: 6px;
-      display: none;
+      font-weight: 800;
+      line-height: 1.35;
     }
-    .card:hover .card-edit-hint { display: block; }
+    .tag-not-ready { background: #e2e8f0; color: #475569; }
+    .tag-unwritten { background: #fff4cc; color: #8a5a00; }
+    .tag-implementing { background: #ede9fe; color: #5b21b6; }
+    .tag-verifying { background: #fae8ff; color: #86198f; }
+    .tag-priority { background: #ffedd5; color: #9a3412; }
 
     .empty-column {
-      color: #b3bac5;
+      color: #94a3b8;
       font-size: 12px;
       padding: 10px 4px;
       text-align: center;
@@ -72139,29 +72579,23 @@
     .modal-overlay {
       position: fixed;
       inset: 0;
-      background: rgba(9,30,66,0.54);
+      background: rgba(15,23,42,0.58);
       display: flex;
       align-items: flex-start;
       justify-content: center;
-      padding: 60px 16px 16px;
+      padding: 56px 16px 16px;
       z-index: 100;
-      animation: fadeIn 0.1s ease;
     }
     .modal-overlay.hidden { display: none; }
 
-    @keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
-
     .modal {
       background: white;
       border-radius: 8px;
       width: 100%;
-      max-width: 620px;
-      padding: 20px;
-      box-shadow: 0 8px 32px rgba(0,0,0,0.25);
-      animation: slideIn 0.15s ease;
+      max-width: 720px;
+      padding: 18px;
+      box-shadow: 0 14px 40px rgba(15,23,42,0.28);
     }
-    @keyframes slideIn { from { transform: translateY(-8px); opacity: 0; } to { transform: none; opacity: 1; } }
-
     .modal-header {
       display: flex;
       align-items: flex-start;
@@ -72169,62 +72603,59 @@
       margin-bottom: 14px;
       gap: 12px;
     }
-
     .modal-meta { flex: 1; min-width: 0; }
-    .modal-file { font-size: 11px; color: #8993a4; margin-bottom: 4px; }
-    .modal-section-label { font-size: 13px; font-weight: 600; color: #172b4d; }
-
+    .modal-file {
+      font-size: 11px;
+      color: #7b8794;
+      margin-bottom: 4px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .modal-section-label { font-size: 14px; font-weight: 700; color: #1f2933; }
     .modal-status {
       font-size: 11px;
-      font-weight: 700;
-      padding: 2px 8px;
-      border-radius: 10px;
+      font-weight: 800;
+      padding: 3px 8px;
+      border-radius: 999px;
       text-transform: uppercase;
-      letter-spacing: 0.4px;
       flex-shrink: 0;
     }
-    .status-todo      { background: #deebff; color: #0052cc; }
-    .status-not-ready { background: #f4f5f7; color: #5e6c84; }
-    .status-done      { background: #e3fcef; color: #006644; }
-    .status-failed    { background: #ffebe6; color: #bf2600; }
-
+    .status-backlog { background: #e2e8f0; color: #475569; }
+    .status-low-priority { background: #ffedd5; color: #9a3412; }
+    .status-todo { background: #dbeafe; color: #1d4ed8; }
+    .status-in-progress { background: #ede9fe; color: #5b21b6; }
+    .status-done { background: #dcfce7; color: #166534; }
+    .status-errors { background: #fee2e2; color: #991b1b; }
+    .status-finished { background: #cffafe; color: #155e75; }
     .modal-close {
-      background: none;
-      border: none;
-      color: #8993a4;
+      background: transparent;
+      border: 0;
+      color: #64748b;
       cursor: pointer;
-      font-size: 18px;
+      font-size: 20px;
       padding: 0 4px;
       line-height: 1;
-      flex-shrink: 0;
     }
-    .modal-close:hover { color: #172b4d; }
+    .modal-close:hover { color: #1f2933; }
 
     textarea {
       width: 100%;
-      min-height: 220px;
-      font-family: 'SFMono-Regular', 'Consolas', 'Courier New', monospace;
+      min-height: 300px;
+      font-family: "SFMono-Regular", Consolas, "Courier New", monospace;
       font-size: 13px;
-      border: 2px solid #dfe1e6;
+      border: 2px solid #d8dee8;
       border-radius: 4px;
       padding: 10px 12px;
       resize: vertical;
-      line-height: 1.65;
-      color: #172b4d;
-      transition: border-color 0.15s;
+      line-height: 1.6;
+      color: #1f2933;
     }
     textarea:focus {
       outline: none;
-      border-color: #0052cc;
-      box-shadow: 0 0 0 3px rgba(0,82,204,0.12);
+      border-color: #2563eb;
+      box-shadow: 0 0 0 3px rgba(37,99,235,0.12);
     }
-
-    .modal-hint {
-      font-size: 11px;
-      color: #8993a4;
-      margin-top: 6px;
-    }
-
     .modal-actions {
       display: flex;
       gap: 8px;
@@ -72232,67 +72663,50 @@
       justify-content: flex-end;
     }
 
-    .btn-save   { background: #0052cc; color: white; }
-    .btn-cancel { background: #f4f5f7; color: #172b4d; }
-    .btn-cancel:hover { background: #ebecf0; opacity: 1; }
-
     .error-banner {
-      background: #ffebe6;
-      border-bottom: 2px solid #bf2600;
-      color: #bf2600;
-      padding: 8px 20px;
+      background: #fee2e2;
+      border-bottom: 2px solid #b42318;
+      color: #991b1b;
+      padding: 8px 18px;
       font-size: 13px;
-      font-weight: 500;
+      font-weight: 700;
     }
     .error-banner.hidden { display: none; }
+
+    @media (max-width: 860px) {
+      header { flex-wrap: wrap; }
+      #pause-label { order: 4; flex-basis: 100%; }
+      .run-strip { grid-template-columns: 1fr; }
+      .board { min-height: calc(100vh - 212px); }
+    }
   </style>
 </head>
 <body>
-
   <div id="error-banner" class="error-banner hidden"></div>
 
   <header>
-    <h1>&#128295; Ptbk Coder Server</h1>
+    <h1>Ptbk Coder Server</h1>
     <span id="status-badge" class="status-badge status-RUNNING">RUNNING</span>
     <span id="pause-label"></span>
-    <button id="toggle-btn" class="btn btn-pause">&#9646;&#9646; Pause</button>
+    <button id="toggle-btn" class="btn btn-pause">Pause</button>
   </header>
 
-  <div class="board">
-    <div class="column">
-      <div class="column-header">
-        To Do
-        <span class="column-count" id="count-todo">0</span>
-      </div>
-      <div class="column-cards" id="cards-todo">
-        <div class="empty-column">Loading&hellip;</div>
-      </div>
+  <section class="run-strip">
+    <div>
+      <div class="run-title" id="run-title">Initializing...</div>
+      <div class="run-subtitle" id="run-subtitle">Loading runner state</div>
     </div>
-
-    <div class="column">
-      <div class="column-header">
-        Not Ready
-        <span class="column-count" id="count-not-ready">0</span>
-      </div>
-      <div class="column-cards" id="cards-not-ready"></div>
+    <div class="progress-shell">
+      <div class="progress-track"><span class="progress-fill" id="progress-fill"></span></div>
+      <div class="progress-label" id="progress-label">0%</div>
     </div>
-
-    <div class="column">
-      <div class="column-header">
-        Done
-        <span class="column-count" id="count-done">0</span>
-      </div>
-      <div class="column-cards" id="cards-done"></div>
+    <div>
+      <div class="run-current" id="run-current">No active prompt</div>
+      <div class="run-output" id="run-output"></div>
     </div>
+  </section>
 
-    <div class="column">
-      <div class="column-header">
-        Failed
-        <span class="column-count" id="count-failed">0</span>
-      </div>
-      <div class="column-cards" id="cards-failed"></div>
-    </div>
-  </div>
+  <div class="board" id="board"></div>
 
   <div class="modal-overlay hidden" id="modal-overlay">
     <div class="modal">
@@ -72302,196 +72716,317 @@
           <div class="modal-section-label" id="modal-section-label"></div>
         </div>
         <span class="modal-status" id="modal-status-badge"></span>
-        <button class="modal-close" onclick="closeModal()" title="Close (Esc)">&#x2715;</button>
+        <button class="modal-close" id="modal-close" title="Close">&times;</button>
       </div>
 
-      <textarea id="modal-content" placeholder="Prompt content&hellip;"></textarea>
-      <div class="modal-hint">Tip: press Ctrl+Enter to save, Esc to cancel.</div>
+      <textarea id="modal-content" placeholder="Prompt content"></textarea>
 
       <div class="modal-actions">
-        <button class="btn btn-cancel" onclick="closeModal()">Cancel</button>
-        <button class="btn btn-save" onclick="saveModal()">Save</button>
+        <button class="btn btn-cancel" id="cancel-button">Cancel</button>
+        <button class="btn btn-save" id="save-button">Save</button>
       </div>
     </div>
   </div>
 
   <script>
-    'use strict';
+    "use strict";
+
+    const BOARD_COLUMNS = [
+      { id: "backlog", title: "Backlog" },
+      { id: "low-priority", title: "Low priority" },
+      { id: "todo", title: "To do" },
+      { id: "in-progress", title: "In progress" },
+      { id: "done", title: "Done" },
+      { id: "errors", title: "Errors" },
+      { id: "finished", title: "Finished" },
+    ];
 
     let modalState = null;
-    let lastPauseState = 'RUNNING';
+    let lastPauseState = "RUNNING";
+
+    function getColumnTitle(columnId) {
+      const column = BOARD_COLUMNS.find((columnCandidate) => columnCandidate.id === columnId);
+      return column ? column.title : columnId;
+    }
+
+    function showError(message) {
+      const banner = document.getElementById("error-banner");
+      banner.textContent = message;
+      banner.classList.remove("hidden");
+      clearTimeout(banner.timer);
+      banner.timer = setTimeout(() => banner.classList.add("hidden"), 6000);
+    }
+
+    function escapeHtml(value) {
+      const element = document.createElement("div");
+      element.textContent = String(value);
+      return element.innerHTML;
+    }
+
+    function renderBoardSkeleton() {
+      const board = document.getElementById("board");
+      board.innerHTML = "";
+
+      for (const column of BOARD_COLUMNS) {
+        const columnElement = document.createElement("section");
+        columnElement.className = "column column-" + column.id;
+        columnElement.innerHTML =
+          '<div class="column-header">' +
+            '<span>' + escapeHtml(column.title) + '</span>' +
+            '<span class="column-count" id="count-' + column.id + '">0</span>' +
+          '</div>' +
+          '<div class="column-cards" id="cards-' + column.id + '">' +
+            '<div class="empty-column">Loading</div>' +
+          '</div>';
+        board.appendChild(columnElement);
+      }
+    }
 
-    function showError(msg) {
-      const banner = document.getElementById('error-banner');
-      banner.textContent = '\\u26a0 ' + msg;
-      banner.classList.remove('hidden');
-      clearTimeout(banner._timer);
-      banner._timer = setTimeout(() => banner.classList.add('hidden'), 6000);
+    async function fetchStatus() {
+      try {
+        const response = await fetch("/api/status");
+        if (!response.ok) {
+          showError("Status API error: " + response.status);
+          return;
+        }
+
+        const status = await response.json();
+        renderPauseState(status);
+        renderRunState(status.runState);
+      } catch (error) {
+        showError("Could not reach coder server: " + error.message);
+      }
     }
 
-    function escapeHtml(str) {
-      const d = document.createElement('div');
-      d.textContent = String(str);
-      return d.innerHTML;
+    function renderPauseState(status) {
+      lastPauseState = status.pauseState;
+
+      const badge = document.getElementById("status-badge");
+      badge.textContent = status.pauseState;
+      badge.className = "status-badge status-" + status.pauseState;
+
+      const toggleButton = document.getElementById("toggle-btn");
+      const pauseLabel = document.getElementById("pause-label");
+
+      if (status.pauseState === "RUNNING") {
+        toggleButton.textContent = "Pause";
+        toggleButton.className = "btn btn-pause";
+        pauseLabel.textContent = "";
+        return;
+      }
+
+      toggleButton.textContent = "Resume";
+      toggleButton.className = "btn btn-resume";
+      pauseLabel.textContent =
+        (status.pauseState === "PAUSING" ? "Pausing before: " : "Paused before: ") +
+        (status.pauseTargetLabel || "next checkpoint");
     }
 
-    async function fetchStatus() {
-      try {
-        const res = await fetch('/api/status');
-        if (!res.ok) { showError('Status API error: ' + res.status); return; }
-        const data = await res.json();
-
-        lastPauseState = data.pauseState;
-
-        const badge = document.getElementById('status-badge');
-        badge.textContent = data.pauseState;
-        badge.className = 'status-badge status-' + data.pauseState;
-
-        const btn   = document.getElementById('toggle-btn');
-        const label = document.getElementById('pause-label');
-
-        if (data.pauseState === 'RUNNING') {
-          btn.textContent = '\\u23f8 Pause';
-          btn.className   = 'btn btn-pause';
-          label.textContent = '';
-        } else if (data.pauseState === 'PAUSING') {
-          btn.textContent = '\\u23f5 Resume';
-          btn.className   = 'btn btn-resume';
-          label.textContent = 'Pausing before: ' + (data.pauseTargetLabel || '\\u2026');
-        } else {
-          btn.textContent = '\\u23f5 Resume';
-          btn.className   = 'btn btn-resume';
-          label.textContent = 'Paused before: ' + (data.pauseTargetLabel || '\\u2026');
-        }
-      } catch (e) {
-        showError('Could not reach coder server: ' + e.message);
+    function renderRunState(runState) {
+      if (!runState) {
+        document.getElementById("run-title").textContent = "Waiting for runner state";
+        document.getElementById("run-subtitle").textContent = "";
+        return;
       }
+
+      const progress = runState.progress || {};
+      const percentage = Number(progress.percentage || 0);
+      const runnerParts = [runState.config.agentName, runState.config.modelName, runState.config.thinkingLevel]
+        .filter(Boolean);
+
+      document.getElementById("run-title").textContent = runState.statusMessage || runState.phase;
+      document.getElementById("run-subtitle").textContent = runnerParts.join(" / ");
+      document.getElementById("progress-fill").style.width = Math.max(0, Math.min(100, percentage)) + "%";
+      document.getElementById("progress-label").textContent =
+        percentage + "% " + (progress.sessionDone || 0) + "/" + (progress.sessionTotal || 0);
+      document.getElementById("run-current").textContent = runState.currentPromptLabel
+        ? runState.currentPromptLabel + " - attempt " + runState.currentAttempt + "/" + runState.maxAttempts
+        : "No active prompt";
+
+      renderRunOutput(runState);
+    }
+
+    function renderRunOutput(runState) {
+      const statusLines = (runState.agentStatusTableRows || []).map((row) =>
+        row.status + " - " + row.agentName + (row.url ? " - " + row.url : "")
+      );
+      const outputLines = [
+        ...(runState.agentStatusLines || []),
+        ...statusLines,
+        ...(runState.agentOutputLines || []),
+        ...(runState.errors || []).map((errorLine) => "Error: " + errorLine),
+      ].slice(-3);
+
+      document.getElementById("run-output").textContent = outputLines.join("\\n");
     }
 
     async function fetchPrompts() {
       try {
-        const res = await fetch('/api/prompts');
-        if (!res.ok) { showError('Prompts API error: ' + res.status); return; }
-        renderBoard(await res.json());
-      } catch (e) {
-        showError('Could not load prompts: ' + e.message);
+        const response = await fetch("/api/prompts");
+        if (!response.ok) {
+          showError("Prompts API error: " + response.status);
+          return;
+        }
+
+        renderBoard(await response.json());
+      } catch (error) {
+        showError("Could not load prompts: " + error.message);
       }
     }
 
     function renderBoard(promptFiles) {
-      const columns = { 'todo': [], 'not-ready': [], 'done': [], 'failed': [] };
+      const columns = Object.fromEntries(BOARD_COLUMNS.map((column) => [column.id, []]));
 
       for (const file of promptFiles) {
         for (const section of file.sections) {
-          const col = columns[section.status];
-          if (col) col.push({ file, section });
+          if (columns[section.column]) {
+            columns[section.column].push({ file, section });
+          }
         }
       }
 
-      for (const [status, cards] of Object.entries(columns)) {
-        const container = document.getElementById('cards-' + status);
-        const countEl   = document.getElementById('count-' + status);
-        if (!container) continue;
+      for (const column of BOARD_COLUMNS) {
+        renderColumn(column.id, columns[column.id]);
+      }
+    }
 
-        countEl.textContent = cards.length;
-        container.innerHTML = '';
+    function renderColumn(columnId, cards) {
+      const container = document.getElementById("cards-" + columnId);
+      const countElement = document.getElementById("count-" + columnId);
 
-        if (cards.length === 0) {
-          container.innerHTML = '<div class="empty-column">Empty</div>';
-          continue;
-        }
+      countElement.textContent = cards.length;
+      container.innerHTML = "";
 
-        for (const { file, section } of cards) {
-          const card = document.createElement('div');
-          card.className = 'card card-' + section.status;
-          card.innerHTML =
-            '<div class="card-file">' + escapeHtml(file.fileName) + ' &bull; #' + (section.index + 1) + '</div>' +
-            '<div class="card-summary">' + escapeHtml(section.summary) + '</div>' +
-            (section.priority > 0
-              ? '<div class="card-priority">' + '!'.repeat(section.priority) + ' priority ' + section.priority + '</div>'
-              : '') +
-            '<div class="card-edit-hint">Click to edit</div>';
-          card.onclick = () => openModal(file, section);
-          container.appendChild(card);
-        }
+      if (cards.length === 0) {
+        container.innerHTML = '<div class="empty-column">Empty</div>';
+        return;
+      }
+
+      for (const cardData of cards) {
+        container.appendChild(createPromptCard(cardData.file, cardData.section));
+      }
+    }
+
+    function createPromptCard(file, section) {
+      const card = document.createElement("article");
+      card.className = "card card-" + section.column;
+      card.innerHTML =
+        '<div class="card-file">' + escapeHtml(file.relativeFilePath || file.fileName) + " #" + (section.index + 1) + '</div>' +
+        '<div class="card-summary">' + escapeHtml(section.summary) + '</div>' +
+        renderTags(section);
+      card.onclick = () => openModal(file, section);
+      return card;
+    }
+
+    function renderTags(section) {
+      const tags = [...(section.tags || [])];
+      if (section.priority > 0) {
+        tags.push({ id: "priority", label: "P" + section.priority });
       }
+
+      if (tags.length === 0) {
+        return "";
+      }
+
+      return '<div class="card-tags">' + tags.map((tag) =>
+        '<span class="card-tag tag-' + escapeHtml(tag.id) + '">' + escapeHtml(tag.label) + '</span>'
+      ).join("") + '</div>';
     }
 
     function openModal(file, section) {
       modalState = { filePath: file.filePath, sectionIndex: section.index };
 
-      document.getElementById('modal-file').textContent          = file.fileName;
-      document.getElementById('modal-section-label').textContent = 'Section ' + (section.index + 1);
+      document.getElementById("modal-file").textContent = file.relativeFilePath || file.fileName;
+      document.getElementById("modal-section-label").textContent = "Section " + (section.index + 1);
 
-      const badge = document.getElementById('modal-status-badge');
-      badge.textContent = section.status.replace('-', '\\u2011');
-      badge.className   = 'modal-status status-' + section.status;
+      const statusBadge = document.getElementById("modal-status-badge");
+      statusBadge.textContent = getColumnTitle(section.column);
+      statusBadge.className = "modal-status status-" + section.column;
 
-      document.getElementById('modal-content').value = section.content;
-      document.getElementById('modal-overlay').classList.remove('hidden');
-      setTimeout(() => document.getElementById('modal-content').focus(), 50);
+      document.getElementById("modal-content").value = section.content;
+      document.getElementById("modal-overlay").classList.remove("hidden");
+      setTimeout(() => document.getElementById("modal-content").focus(), 50);
     }
 
     function closeModal() {
-      document.getElementById('modal-overlay').classList.add('hidden');
+      document.getElementById("modal-overlay").classList.add("hidden");
       modalState = null;
     }
 
     async function saveModal() {
-      if (!modalState) return;
+      if (!modalState) {
+        return;
+      }
 
-      const content = document.getElementById('modal-content').value;
-      const saveBtn = document.querySelector('.btn-save');
-      saveBtn.disabled    = true;
-      saveBtn.textContent = 'Saving\\u2026';
+      const content = document.getElementById("modal-content").value;
+      const saveButton = document.getElementById("save-button");
+      saveButton.disabled = true;
+      saveButton.textContent = "Saving...";
 
       try {
-        const res = await fetch('/api/prompts/update', {
-          method: 'PUT',
-          headers: { 'Content-Type': 'application/json' },
+        const response = await fetch("/api/prompts/update", {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
-            filePath:     modalState.filePath,
+            filePath: modalState.filePath,
             sectionIndex: modalState.sectionIndex,
             content,
           }),
         });
-        if (!res.ok) throw new Error('HTTP ' + res.status);
+
+        if (!response.ok) {
+          throw new Error("HTTP " + response.status);
+        }
+
         closeModal();
-        fetchPrompts();
-      } catch (e) {
-        showError('Save failed: ' + e.message);
+        await fetchPrompts();
+      } catch (error) {
+        showError("Save failed: " + error.message);
       } finally {
-        saveBtn.disabled    = false;
-        saveBtn.textContent = 'Save';
+        saveButton.disabled = false;
+        saveButton.textContent = "Save";
       }
     }
 
-    document.getElementById('toggle-btn').onclick = async () => {
+    document.getElementById("toggle-btn").onclick = async () => {
       try {
-        const endpoint = lastPauseState === 'RUNNING' ? '/api/pause' : '/api/resume';
-        await fetch(endpoint, { method: 'POST' });
+        const endpoint = lastPauseState === "RUNNING" ? "/api/pause" : "/api/resume";
+        await fetch(endpoint, { method: "POST" });
         await fetchStatus();
-      } catch (e) {
-        showError('Toggle failed: ' + e.message);
+      } catch (error) {
+        showError("Toggle failed: " + error.message);
       }
     };
 
-    document.addEventListener('keydown', (e) => {
-      if (e.key === 'Escape') { closeModal(); return; }
-      if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') { saveModal(); return; }
+    document.getElementById("modal-close").onclick = closeModal;
+    document.getElementById("cancel-button").onclick = closeModal;
+    document.getElementById("save-button").onclick = saveModal;
+
+    document.addEventListener("keydown", (event) => {
+      if (event.key === "Escape") {
+        closeModal();
+        return;
+      }
+      if ((event.ctrlKey || event.metaKey) && event.key === "Enter") {
+        saveModal();
+      }
     });
 
-    document.getElementById('modal-overlay').addEventListener('click', (e) => {
-      if (e.target === document.getElementById('modal-overlay')) closeModal();
+    document.getElementById("modal-overlay").addEventListener("click", (event) => {
+      if (event.target === document.getElementById("modal-overlay")) {
+        closeModal();
+      }
     });
 
+    renderBoardSkeleton();
     fetchStatus();
     fetchPrompts();
-    setInterval(fetchStatus,  2000);
+    setInterval(fetchStatus, 2000);
     setInterval(fetchPrompts, 5000);
   </script>
 </body>
-</html>`;
+</html>
+`;
     // Note: [🟡] Code for CLI command [coder server](scripts/run-codex-prompts/server/coderServerHtml.ts) should never be published outside of `@promptbook/cli`
     // Note: Keep in sync with apps/coder-server/index.html
 
@@ -72501,6 +73036,12 @@
      * @private internal constant of `ptbk coder server`
      */
     const PROMPTS_DIRECTORY_NAME = 'prompts';
+    /**
+     * Directory containing human-verified prompt files, relative to `prompts/`.
+     *
+     * @private internal constant of `ptbk coder server`
+     */
+    const FINISHED_PROMPTS_DIRECTORY_NAME = 'done';
     /**
      * Starts the lightweight HTTP server that serves the coder kanban UI and REST API.
      *
@@ -72514,24 +73055,29 @@
      *
      * @private internal utility of `ptbk coder server`
      */
-    function startCoderHttpServer(port) {
+    function startCoderHttpServer(options) {
+        const { port, minimumPriority, serverUrl, uiState } = options;
         const promptsDir = path.join(process.cwd(), PROMPTS_DIRECTORY_NAME);
-        const server = http.createServer(async (req, res) => {
+        const server = http.createServer(async (request, response) => {
             try {
-                await handleRequest(req, res, promptsDir);
+                await handleRequest(request, response, {
+                    promptsDir,
+                    minimumPriority,
+                    uiState,
+                });
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 console.error(colors__default["default"].red(`Coder server request error: ${message}`));
-                if (!res.headersSent) {
-                    res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
+                if (!response.headersSent) {
+                    response.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
                 }
-                res.end('Internal server error');
+                response.end('Internal server error');
             }
         });
         server.listen(port, () => {
             console.info(_spaceTrim.spaceTrim(`
-                Coder server running at ${colors__default["default"].cyan(`http://localhost:${port}`)}
+                Coder server running at ${colors__default["default"].cyan(serverUrl)}
                 Open the URL above in your browser to see the kanban board.
                 Press ${colors__default["default"].bold('p')} to pause / resume the agent runner.
             `));
@@ -72545,51 +73091,57 @@
     /**
      * Routes one HTTP request to the appropriate handler.
      */
-    async function handleRequest(req, res, promptsDir) {
-        const urlPath = new URL(req.url || '/', `http://localhost`).pathname;
-        const method = (req.method || 'GET').toUpperCase();
+    async function handleRequest(request, response, options) {
+        const { promptsDir, minimumPriority, uiState } = options;
+        const urlPath = new URL(request.url || '/', `http://localhost`).pathname;
+        const method = (request.method || 'GET').toUpperCase();
         // Serve the kanban UI
         if (urlPath === '/' && method === 'GET') {
-            res.writeHead(200, {
+            response.writeHead(200, {
                 'Content-Type': 'text/html; charset=utf-8',
                 'Cache-Control': 'no-cache',
             });
-            res.end(CODER_SERVER_HTML);
+            response.end(CODER_SERVER_HTML);
             return;
         }
         // GET /api/status
         if (urlPath === '/api/status' && method === 'GET') {
-            res.writeHead(200, jsonHeaders());
-            res.end(JSON.stringify({
+            response.writeHead(200, jsonHeaders());
+            response.end(JSON.stringify({
                 pauseState: getPauseState(),
                 pauseTargetLabel: getPauseTargetLabel(),
+                runState: uiState ? buildCoderServerRunState(uiState) : undefined,
             }));
             return;
         }
         // GET /api/prompts
         if (urlPath === '/api/prompts' && method === 'GET') {
-            const promptData = await loadPromptsForApi(promptsDir);
-            res.writeHead(200, jsonHeaders());
-            res.end(JSON.stringify(promptData));
+            const promptData = await loadPromptsForApi({
+                promptsDir,
+                minimumPriority,
+                uiState,
+            });
+            response.writeHead(200, jsonHeaders());
+            response.end(JSON.stringify(promptData));
             return;
         }
         // POST /api/pause
         if (urlPath === '/api/pause' && method === 'POST') {
             requestPause();
-            res.writeHead(200, jsonHeaders());
-            res.end(JSON.stringify({ pauseState: getPauseState() }));
+            response.writeHead(200, jsonHeaders());
+            response.end(JSON.stringify({ pauseState: getPauseState() }));
             return;
         }
         // POST /api/resume
         if (urlPath === '/api/resume' && method === 'POST') {
             requestResume();
-            res.writeHead(200, jsonHeaders());
-            res.end(JSON.stringify({ pauseState: getPauseState() }));
+            response.writeHead(200, jsonHeaders());
+            response.end(JSON.stringify({ pauseState: getPauseState() }));
             return;
         }
         // PUT /api/prompts/update
         if (urlPath === '/api/prompts/update' && method === 'PUT') {
-            const body = await readRequestBody(req);
+            const body = await readRequestBody(request);
             const parsed = JSON.parse(body);
             if (typeof parsed.filePath !== 'string' ||
                 typeof parsed.sectionIndex !== 'number' ||
@@ -72600,49 +73152,85 @@
                     Expected: \`{ filePath: string, sectionIndex: number, content: string }\`
                 `));
             }
-            await updatePromptSection(parsed.filePath, parsed.sectionIndex, parsed.content);
-            res.writeHead(200, jsonHeaders());
-            res.end(JSON.stringify({ success: true }));
+            const promptFilePath = resolveEditablePromptFilePath(parsed.filePath, promptsDir);
+            const isUpdated = await updatePromptSection(promptFilePath, parsed.sectionIndex, parsed.content);
+            if (isUpdated) {
+                await commitPromptEdit(promptFilePath, parsed.sectionIndex);
+            }
+            response.writeHead(200, jsonHeaders());
+            response.end(JSON.stringify({ success: true, committed: isUpdated }));
             return;
         }
-        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
-        res.end('Not found');
+        response.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+        response.end('Not found');
     }
     /**
      * Loads all prompt files and converts them to the API response shape.
      */
-    async function loadPromptsForApi(promptsDir) {
+    async function loadPromptsForApi(options) {
+        const { promptsDir, minimumPriority, uiState } = options;
+        const promptFiles = await loadPromptFilesSafely(promptsDir);
+        const finishedPromptFiles = await loadPromptFilesSafely(path.join(promptsDir, FINISHED_PROMPTS_DIRECTORY_NAME));
+        return buildCoderServerPromptFileResponses({
+            promptFiles,
+            finishedPromptFiles,
+            minimumPriority,
+            uiState,
+        });
+    }
+    /**
+     * Loads prompt files from a directory that may not exist yet.
+     */
+    async function loadPromptFilesSafely(promptsDir) {
         try {
-            const promptFiles = await loadPromptFiles(promptsDir);
-            return promptFiles.map((file) => ({
-                filePath: file.path,
-                fileName: file.name,
-                sections: file.sections.map((section) => ({
-                    index: section.index,
-                    status: section.status,
-                    priority: section.priority,
-                    summary: buildPromptSummary(file, section),
-                    content: buildCodexPrompt(file, section),
-                })),
-            }));
+            return await loadPromptFiles(promptsDir);
         }
         catch (error) {
-            // Prompts directory may not exist yet; return empty list
             if (error.code === 'ENOENT') {
                 return [];
             }
             throw error;
         }
     }
+    /**
+     * Resolves and validates one editable prompt file path received from the browser.
+     */
+    function resolveEditablePromptFilePath(filePath, promptsDir) {
+        const promptFilePath = path.resolve(filePath);
+        const promptsDirectoryPath = path.resolve(promptsDir);
+        const relativePromptFilePath = path.relative(promptsDirectoryPath, promptFilePath);
+        const isOutsidePromptsDirectory = relativePromptFilePath === '' ||
+            relativePromptFilePath.startsWith('..') ||
+            path.isAbsolute(relativePromptFilePath);
+        if (isOutsidePromptsDirectory || !promptFilePath.toLowerCase().endsWith('.md')) {
+            throw new NotAllowed(_spaceTrim.spaceTrim(`
+                Prompt file edits are limited to Markdown files inside \`${promptsDirectoryPath}\`.
+
+                Requested file:
+                \`${filePath}\`
+            `));
+        }
+        return promptFilePath;
+    }
+    /**
+     * Commits a browser prompt edit to Git without sweeping unrelated staged files into the commit.
+     */
+    async function commitPromptEdit(promptFilePath, sectionIndex) {
+        const relativePromptFilePath = path.relative(process.cwd(), promptFilePath).replace(/\\/gu, '/');
+        await commitChanges(`Edit coder prompt ${relativePromptFilePath}#${sectionIndex + 1}`, {
+            includePaths: [relativePromptFilePath],
+            onlyPaths: [relativePromptFilePath],
+        });
+    }
     /**
      * Reads the full request body as a UTF-8 string.
      */
-    function readRequestBody(req) {
+    function readRequestBody(request) {
         return new Promise((resolve, reject) => {
             const chunks = [];
-            req.on('data', (chunk) => chunks.push(chunk));
-            req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-            req.on('error', reject);
+            request.on('data', (chunk) => chunks.push(chunk));
+            request.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+            request.on('error', reject);
         });
     }
     /**
@@ -72671,12 +73259,21 @@
      */
     async function runCodexPromptsServer(options) {
         const { port, ...runOptions } = options;
-        const serverHandle = startCoderHttpServer(port);
+        const serverUrl = `http://localhost:${port}`;
+        const uiState = new CoderRunUiState(moment__default["default"]());
+        const serverHandle = startCoderHttpServer({
+            port,
+            minimumPriority: runOptions.priority,
+            serverUrl,
+            uiState,
+        });
         console.info(colors__default["default"].gray('Starting prompt runner in server (keep-alive) mode…'));
         try {
             await runCodexPrompts({
                 ...runOptions,
                 keepAlive: true,
+                serverUrl,
+                uiState,
             });
         }
         finally {