@promptbook/cli 0.112.0-126 → 0.112.0-127

package/esm/index.es.js

@@ -37,10 +37,10 @@ import * as ts from 'typescript';
 import ignore from 'ignore';
 import * as readline from 'readline';
 import { emitKeypressEvents, clearLine, cursorTo, createInterface } from 'readline';
+import { EventEmitter } from 'events';
 import { lookup, extension } from 'mime-types';
 import papaparse from 'papaparse';
 import { pathToFileURL } from 'url';
-import { EventEmitter } from 'events';
 import { Client } from 'pg';
 import '@supabase/supabase-js';
 
@@ -58,7 +58,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-126';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-127';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2692,8 +2692,16 @@ function createAgentsServerEnvVariable(name, value) {
  * 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$1(`
+            ${AGENTS_SERVER_ENV_CREATED_COMMENT}
+            # Documentation: ${documentationUrl}
+            ${name}=${value}
+        `));
+    return spaceTrim$1((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`
 
@@ -4265,6 +4273,13 @@ function buildScriptPathSessionRows(scriptPaths, bodyWidth) {
         },
     ];
 }
+/**
+ * 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.
  */
@@ -4455,6 +4470,9 @@ function buildSessionRows(options, bodyWidth, pausePresentation) {
     }
     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 [
@@ -4897,7 +4915,8 @@ function getTerminalWidth() {
  * @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 {
@@ -7876,8 +7895,11 @@ class GoalCommitmentDefinition extends BaseCommitmentDefinition {
         if (!trimmedContent) {
             return requirements;
         }
-        // Add goal as a proper h2 section to the system message
-        const goalSection = `## Goal\n\n${trimmedContent}`;
+        const goalSection = spaceTrim$1((block) => `
+                ## Goal
+
+                ${block(trimmedContent)}
+            `);
         const requirementsWithGoal = this.appendToSystemMessage(requirements, goalSection, '\n\n');
         return this.appendToPromptSuffix(requirementsWithGoal, trimmedContent);
     }
@@ -8399,8 +8421,11 @@ class LanguageCommitmentDefinition extends BaseCommitmentDefinition {
         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$1((block) => `
+                ## Language
+
+                -   Your language is ${block(trimmedContent)}
+            `);
         return this.appendToSystemMessage(requirements, languageSection, '\n\n');
     }
 }
@@ -13365,41 +13390,91 @@ function drawBlobbyOctopusShadow(context, size, palette, interaction, timeMs, mo
     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`,
@@ -13417,12 +13492,21 @@ function resolveVisibleBlobbyOctopusPatches(options) {
  * @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) -
@@ -13719,45 +13803,102 @@ function drawContinuousOctopusShadow(context, size, palette, interaction, timeMs
     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`,
             });
         }
@@ -13773,16 +13914,27 @@ function resolveVisibleContinuousOctopusPatches(options) {
  * @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)) *
@@ -17187,7 +17339,15 @@ function buildTeammateMetadata(entry) {
  * 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$1((block) => `
+            ${block(message)}
+
+            Context:
+            ${block(context)}
+        `);
 }
 /**
  * Builds a minimal chat prompt for teammate calls.
@@ -21210,7 +21370,11 @@ function createUseProjectToolFunctions() {
                 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$1((block) => `
+                              ${block(lineRangedContent.slice(0, MAX_PROJECT_FILE_CONTENT_CHARACTERS))}
+
+                              [...truncated...]
+                          `)
                     : lineRangedContent;
                 const wasTruncated = decoded.isTruncated || wasCharacterTruncated;
                 if (wasCharacterTruncated) {
@@ -26085,7 +26249,8 @@ function readOptionalSigningKeyValue() {
 /**
  * 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();
@@ -26097,7 +26262,7 @@ async function commitChanges(message, options) {
         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,
         });
@@ -26277,12 +26442,15 @@ async function executeGitPushCommand(command, projectPath, agentEnv) {
 /**
  * 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(' ');
 }
 /**
@@ -27780,7 +27948,11 @@ function createOutputSnippet(output) {
     if (normalized.length <= OUTPUT_SNIPPET_MAX_CHARS) {
         return normalized;
     }
-    return `${normalized.slice(0, OUTPUT_SNIPPET_MAX_CHARS)}\n\n...[truncated]`;
+    return spaceTrim$1((block) => `
+            ${block(normalized.slice(0, OUTPUT_SNIPPET_MAX_CHARS))}
+
+            ...[truncated]
+        `);
 }
 /**
  * Builds one command failure message that keeps a useful snippet of CLI output.
@@ -27790,7 +27962,11 @@ function buildCommandFailureMessage(scriptPathPosix, code, fullOutput) {
     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$1((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.
@@ -27907,7 +28083,9 @@ async function runScriptUntilMarkerIdle(options) {
          * 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) {
@@ -27925,8 +28103,14 @@ async function runScriptUntilMarkerIdle(options) {
         });
         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$1((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);
         });
     });
@@ -28265,7 +28449,11 @@ function limitErrorDetails(details, maxChars = 4000) {
     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.
@@ -34914,11 +35102,19 @@ const JsonFileImportPlugin = {
         try {
             const json = JSON.parse(content);
             const formattedJson = JSON.stringify(json, null, 4);
-            return `\`\`\`json\n${formattedJson}\n\`\`\``;
+            return spaceTrim$1((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$1((block) => `
+                    \`\`\`json
+                    ${block(content)}
+                    \`\`\`
+                `);
         }
     },
 };
@@ -34942,7 +35138,11 @@ const TextFileImportPlugin = {
     import(content, mimeType) {
         const extension = mimeTypeToExtension(mimeType);
         const codeBlockType = extension || 'txt';
-        return `\`\`\`${codeBlockType}\n${content}\n\`\`\``;
+        return spaceTrim$1((block) => `
+                \`\`\`${codeBlockType}
+                ${block(content)}
+                \`\`\`
+            `);
     },
 };
 
@@ -35189,11 +35389,19 @@ function collectExampleInteractionLines(parseResult, samples) {
     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$1((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$1((block) => `
+                        **User:** ${block(String(sample.question))}
+
+                        **Agent:**
+                        ${block(sample.answer)}
+                    `));
         }
     }
     return examples;
@@ -35628,10 +35836,14 @@ async function createAgentRunnerSystemMessage(agentSource) {
  * 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$1((block) => `
+                      ## Prompt suffix
+                      ${block(promptSuffix)}
+                  `)
             : '',
     ]
         .filter(Boolean)
@@ -39284,7 +39496,7 @@ async function ensureCoderGitignoreFile(projectPath) {
  */
 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',
 };
@@ -39743,33 +39955,26 @@ function $initializeCoderRunCommand(program) {
     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$1(`
-            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$1(`
+            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,
@@ -39882,30 +40087,23 @@ function $initializeCoderServerCommand(program) {
     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$1(`
-            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$1(`
+            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,
@@ -40511,7 +40709,12 @@ function colorizeAvailableProviderMessage(providerMessage, { isInstalled, isFull
  * @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$1(`
+              Used \`.env\` file:
+              ${$usedEnvFilename}
+          `);
 }
 // TODO: [®] DRY Register logic
 // TODO: [🧠][⚛] Maybe pass env as argument
@@ -53101,7 +53304,11 @@ function $addGlobalOptionsToCommand(command) {
  * @private utility of CLI
  */
 function $deprecateCliCommand(command, deprecationMessage) {
-    command.description(`${command.description()}\n\nDeprecated: ${deprecationMessage}`);
+    command.description(spaceTrim$1((block) => `
+                ${block(command.description())}
+
+                Deprecated: ${block(deprecationMessage)}
+            `));
     command.hook('preAction', () => {
         console.warn(colors.yellow(createDeprecatedCliCommandWarning(command, deprecationMessage)));
     });
@@ -65910,7 +66117,11 @@ function truncateAttachmentInlineText(content, maxCharacters) {
         };
     }
     return {
-        content: `${content.slice(0, Math.max(0, maxCharacters))}\n\n[...truncated...]`,
+        content: spaceTrim$1((block) => `
+                ${block(content.slice(0, Math.max(0, maxCharacters)))}
+
+                [...truncated...]
+            `),
         isTruncated: true,
     };
 }
@@ -69210,7 +69421,7 @@ var findUnwrittenPrompts$1 = /*#__PURE__*/Object.freeze({
 /**
  * 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.
  */
@@ -69228,7 +69439,7 @@ const KNOWN_OPTION_FLAGS = new Set([
     '--auto-migrate',
     '--allow-destructive-auto-migrate',
     '--wait',
-    '--no-wait',
+    '--no-auto',
     '--no-commit',
     '--ignore-git-changes',
     '--no-normalize-line-endings',
@@ -69266,22 +69477,20 @@ function parseRunOptions(args) {
     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.');
@@ -69320,23 +69529,6 @@ function parseRunOptions(args) {
         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.
  */
@@ -71313,7 +71505,13 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
     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$1((block) => `
+                  ${block(resolvedAgentSystemMessage.trim())}
+
+                  ## Your Task
+
+                  ${block(taskPrompt)}
+              `)
         : taskPrompt;
     const codexPrompt = appendCoderContext(promptWithAgent, resolvedCoderContext);
     const scriptPath = buildScriptPath(nextPrompt.file, nextPrompt.section);
@@ -71382,11 +71580,11 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
  */
 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.blue(`Processing ${promptLabel}`));
@@ -71656,7 +71854,7 @@ function validateRunCodexPromptOptions(options) {
     }
     if (options.noCommit && !options.waitForUser && !options.ignoreGitChanges) {
         throw new NotAllowed(spaceTrim$1(`
-                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.
             `));
@@ -71688,7 +71886,11 @@ async function pullLatestChangesIfEnabled(options) {
 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,
@@ -71753,6 +71955,7 @@ function initializeRunUi(uiHandle, runnerName, actualRunnerModel, options) {
         modelName: actualRunnerModel,
         thinkingLevel: options.thinkingLevel,
         context: options.context,
+        serverUrl: options.serverUrl,
         priority: options.priority,
         testCommand: options.testCommand,
     });
@@ -71911,6 +72114,166 @@ var runCodexPrompts$1 = /*#__PURE__*/Object.freeze({
     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: 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.
  *
@@ -71923,9 +72286,14 @@ async function updatePromptSection(filePath, sectionIndex, newContent) {
     var _a;
     const rawContent = await 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$1(`
+                Prompt section \`${sectionIndex}\` was not found.
+
+                File:
+                \`${filePath}\`
+            `));
     }
     // Lines before the status line (usually empty lines at section start)
     const linesBeforeStatus = section.statusLineIndex !== undefined
@@ -71952,7 +72320,11 @@ async function updatePromptSection(filePath, sectionIndex, newContent) {
         ...promptFile.lines.slice(section.endLine + 1),
     ];
     const updatedContent = updatedLines.join(promptFile.eol) + (promptFile.hasFinalEol ? promptFile.eol : '');
+    if (updatedContent === rawContent) {
+        return false;
+    }
     await 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`
 
@@ -71973,38 +72345,37 @@ const CODER_SERVER_HTML = `<!DOCTYPE html>
   <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;
@@ -72017,57 +72388,122 @@ const CODER_SERVER_HTML = `<!DOCTYPE html>
     }
 
     .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 {
@@ -72075,57 +72511,61 @@ const CODER_SERVER_HTML = `<!DOCTYPE html>
       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;
+      border-left: 3px solid #94a3b8;
     }
-    .card:hover {
-      box-shadow: 0 4px 10px rgba(0,0,0,0.14);
-      transform: translateY(-1px);
-    }
-    .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;
@@ -72134,29 +72574,23 @@ const CODER_SERVER_HTML = `<!DOCTYPE html>
     .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;
@@ -72164,62 +72598,59 @@ const CODER_SERVER_HTML = `<!DOCTYPE html>
       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);
-    }
-
-    .modal-hint {
-      font-size: 11px;
-      color: #8993a4;
-      margin-top: 6px;
+      border-color: #2563eb;
+      box-shadow: 0 0 0 3px rgba(37,99,235,0.12);
     }
-
     .modal-actions {
       display: flex;
       gap: 8px;
@@ -72227,67 +72658,50 @@ const CODER_SERVER_HTML = `<!DOCTYPE html>
       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">
@@ -72297,196 +72711,317 @@ const CODER_SERVER_HTML = `<!DOCTYPE html>
           <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';
-
-    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);
-    }
-
-    function escapeHtml(str) {
-      const d = document.createElement('div');
-      d.textContent = String(str);
-      return d.innerHTML;
+    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);
+      }
     }
 
     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');
+        const response = await fetch("/api/status");
+        if (!response.ok) {
+          showError("Status API error: " + response.status);
+          return;
         }
-      } catch (e) {
-        showError('Could not reach coder server: ' + e.message);
+
+        const status = await response.json();
+        renderPauseState(status);
+        renderRunState(status.runState);
+      } catch (error) {
+        showError("Could not reach coder server: " + error.message);
+      }
+    }
+
+    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");
+    }
+
+    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
 
@@ -72496,6 +73031,12 @@ const CODER_SERVER_HTML = `<!DOCTYPE html>
  * @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.
  *
@@ -72509,24 +73050,29 @@ const PROMPTS_DIRECTORY_NAME = 'prompts';
  *
  * @private internal utility of `ptbk coder server`
  */
-function startCoderHttpServer(port) {
+function startCoderHttpServer(options) {
+    const { port, minimumPriority, serverUrl, uiState } = options;
     const promptsDir = join(process.cwd(), PROMPTS_DIRECTORY_NAME);
-    const server = createServer(async (req, res) => {
+    const server = 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.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$1(`
-                Coder server running at ${colors.cyan(`http://localhost:${port}`)}
+                Coder server running at ${colors.cyan(serverUrl)}
                 Open the URL above in your browser to see the kanban board.
                 Press ${colors.bold('p')} to pause / resume the agent runner.
             `));
@@ -72540,51 +73086,57 @@ function startCoderHttpServer(port) {
 /**
  * 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' ||
@@ -72595,49 +73147,85 @@ async function handleRequest(req, res, promptsDir) {
                     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(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 = resolve(filePath);
+    const promptsDirectoryPath = resolve(promptsDir);
+    const relativePromptFilePath = relative(promptsDirectoryPath, promptFilePath);
+    const isOutsidePromptsDirectory = relativePromptFilePath === '' ||
+        relativePromptFilePath.startsWith('..') ||
+        isAbsolute(relativePromptFilePath);
+    if (isOutsidePromptsDirectory || !promptFilePath.toLowerCase().endsWith('.md')) {
+        throw new NotAllowed(spaceTrim$1(`
+                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 = 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);
     });
 }
 /**
@@ -72666,12 +73254,21 @@ function jsonHeaders() {
  */
 async function runCodexPromptsServer(options) {
     const { port, ...runOptions } = options;
-    const serverHandle = startCoderHttpServer(port);
+    const serverUrl = `http://localhost:${port}`;
+    const uiState = new CoderRunUiState(moment());
+    const serverHandle = startCoderHttpServer({
+        port,
+        minimumPriority: runOptions.priority,
+        serverUrl,
+        uiState,
+    });
     console.info(colors.gray('Starting prompt runner in server (keep-alive) mode…'));
     try {
         await runCodexPrompts({
             ...runOptions,
             keepAlive: true,
+            serverUrl,
+            uiState,
         });
     }
     finally {