@promptbook/cli 0.112.0-102 → 0.112.0-104

package/esm/index.es.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-102';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-104';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3615,16 +3615,30 @@ function resolveNextCliPath() {
 // Note: [🟡] Code for CLI runtime [buildAgentsServer](src/cli/cli-commands/agents-server/buildAgentsServer.ts) should never be published outside of `@promptbook/cli`
 // Note: [💞] Ignore a discrepancy between file name and entity name
 
+/**
+ * Default label used before the next pause checkpoint is known.
+ */
+const DEFAULT_PAUSE_TARGET_LABEL = 'the next task';
 /**
  * Current pause state.
  */
 let pauseState = 'RUNNING';
+/**
+ * Label of the next checkpoint where the requested pause will take effect.
+ */
+let pauseTargetLabel = DEFAULT_PAUSE_TARGET_LABEL;
 /**
  * Stores one new pause state in the shared runner controller.
  */
 function setPauseState(nextPauseState) {
     pauseState = nextPauseState;
 }
+/**
+ * Stores one new pause target label in the shared runner controller.
+ */
+function setPauseTargetLabel(nextPauseTargetLabel) {
+    pauseTargetLabel = nextPauseTargetLabel.trim() || DEFAULT_PAUSE_TARGET_LABEL;
+}
 /**
  * Applies the same three-state toggle used by the `P` hotkey.
  */
@@ -3635,9 +3649,11 @@ function togglePauseState() {
     }
     if (pauseState === 'PAUSING') {
         setPauseState('RUNNING');
+        resetPauseTargetLabel();
         return 'CANCELLED_PAUSE';
     }
     setPauseState('RUNNING');
+    resetPauseTargetLabel();
     return 'RESUMED';
 }
 /**
@@ -3678,7 +3694,8 @@ async function checkPause(options) {
     if (pauseState === 'PAUSING') {
         setPauseState('PAUSED');
         if (!(options === null || options === void 0 ? void 0 : options.silent)) {
-            console.log(colors.bgWhite.black('Paused') + colors.gray(' (Press "p" to resume)'));
+            console.log(colors.bgWhite.black(`Paused before ${getPauseTargetLabel()}`) +
+                colors.gray(' (Press "p" to resume)'));
         }
         (_a = options === null || options === void 0 ? void 0 : options.onPaused) === null || _a === void 0 ? void 0 : _a.call(options);
         while (getPauseState() === 'PAUSED') {
@@ -3696,6 +3713,24 @@ async function checkPause(options) {
 function getPauseState() {
     return pauseState;
 }
+/**
+ * Returns the label of the next checkpoint where pausing will take effect.
+ */
+function getPauseTargetLabel() {
+    return pauseTargetLabel;
+}
+/**
+ * Updates the label of the next pause checkpoint.
+ */
+function announcePauseTargetLabel(nextPauseTargetLabel) {
+    setPauseTargetLabel(nextPauseTargetLabel);
+}
+/**
+ * Restores the default generic pause target label.
+ */
+function resetPauseTargetLabel() {
+    setPauseTargetLabel(DEFAULT_PAUSE_TARGET_LABEL);
+}
 
 /**
  * Just says that the variable is not used but should be kept
@@ -3933,18 +3968,18 @@ function buildScriptPathSessionRows(scriptPaths, bodyWidth) {
 /**
  * Builds the colored phase badge shown in the session box.
  */
-function buildPausePresentation(phase, pauseState, statusMessage) {
+function buildPausePresentation(phase, pauseState, pauseTargetLabel, statusMessage) {
     if (pauseState === 'PAUSING') {
         return {
             badge: colors.bgYellow.black(' PAUSING '),
-            stateMessage: 'Pausing before the next task',
+            stateMessage: `Pausing before ${pauseTargetLabel}`,
             pauseControl: colors.bgMagenta.white(' P ') + colors.white(' Cancel pause'),
         };
     }
     if (pauseState === 'PAUSED') {
         return {
             badge: colors.bgWhite.black(' PAUSED '),
-            stateMessage: 'Paused until resumed',
+            stateMessage: `Paused before ${pauseTargetLabel}`,
             pauseControl: colors.bgGreen.black(' P ') + colors.white(' Resume'),
         };
     }
@@ -4076,7 +4111,7 @@ function buildCoderRunUiFrame(options) {
     const octopusAnimationFrame = isCoderRunUiAutoRefreshing(options.phase, options.pauseState)
         ? options.animationFrame
         : 0;
-    const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.statusMessage);
+    const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.pauseTargetLabel, options.statusMessage);
     const sessionLines = buildSessionLines$1(options, totalWidth, pausePresentation);
     const currentTaskLines = options.currentPromptLabel
         ? [
@@ -4704,6 +4739,7 @@ function renderCoderRunUi(startTime, options = {}) {
             animationFrame: spinnerFrame,
             spinner: SPINNER_FRAMES[spinnerFrame],
             pauseState: getPauseState(),
+            pauseTargetLabel: getPauseTargetLabel(),
             config: state.config,
             phase: state.phase,
             currentPromptLabel: state.currentPromptLabel,
@@ -11005,7 +11041,7 @@ function fillTextureRect(texture, x, y, width, height, color) {
  *
  * @private helper of `minecraft2AvatarVisual`
  */
-const LIGHT_DIRECTION$2 = normalizeVector3({
+const LIGHT_DIRECTION$3 = normalizeVector3({
     x: 0.4,
     y: -0.65,
     z: 0.92,
@@ -11217,7 +11253,7 @@ function resolveVisibleCuboidFaces(cuboid, size, sceneCenterX, sceneCenterY) {
             corners: projectedCorners,
             texture: faceDefinition.texture,
             averageDepth: transformedCorners.reduce((depthSum, corner) => depthSum + corner.z, 0) / transformedCorners.length,
-            lightIntensity: clampNumber$1(dotProduct3D(faceNormal, LIGHT_DIRECTION$2), -1, 1),
+            lightIntensity: clampNumber$1(dotProduct3D(faceNormal, LIGHT_DIRECTION$3), -1, 1),
             outlineColor: cuboid.outlineColor,
         };
     });
@@ -12408,7 +12444,7 @@ function formatAlphaHex(opacity) {
  *
  * @private helper of `octopus3dAvatarVisual`
  */
-const LIGHT_DIRECTION$1 = normalizeVector3({
+const LIGHT_DIRECTION$2 = normalizeVector3({
     x: 0.48,
     y: -0.62,
     z: 0.94,
@@ -12618,7 +12654,7 @@ function resolveVisibleEllipsoidPatches(options) {
                 corners: projectedCorners,
                 averageDepth: transformedCorners.reduce((depthSum, transformedCorner) => depthSum + transformedCorner.z, 0) /
                     transformedCorners.length,
-                lightIntensity: clampNumber$1(dotProduct3D(surfaceNormal, LIGHT_DIRECTION$1), -1, 1),
+                lightIntensity: clampNumber$1(dotProduct3D(surfaceNormal, LIGHT_DIRECTION$2), -1, 1),
                 fillStyle: resolveSurfacePatchFillStyle(palette, verticalProgress + verticalColorBias),
                 outlineColor,
             });
@@ -12807,7 +12843,7 @@ function resolveEllipsoidSurfaceDepth(radiusX, radiusY, radiusZ, x, y) {
  *
  * @private helper of `octopus3d2AvatarVisual`
  */
-const LIGHT_DIRECTION = normalizeVector3({
+const LIGHT_DIRECTION$1 = normalizeVector3({
     x: 0.38,
     y: -0.6,
     z: 0.98,
@@ -12956,7 +12992,7 @@ function resolveVisibleBlobbyOctopusPatches(options) {
                 corners: projectedCorners,
                 averageDepth: transformedCorners.reduce((depthSum, transformedCorner) => depthSum + transformedCorner.z, 0) /
                     transformedCorners.length,
-                lightIntensity: clampNumber$1(dotProduct3D(surfaceNormal, LIGHT_DIRECTION), -1, 1),
+                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`,
             });
@@ -13056,6 +13092,516 @@ function drawBlobbySurfacePatch(context, surfacePatch) {
     context.restore();
 }
 
+/* eslint-disable no-magic-numbers */
+/**
+ * Light direction used by the continuous octopus mesh shading.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+const LIGHT_DIRECTION = normalizeVector3({
+    x: 0.34,
+    y: -0.62,
+    z: 1,
+});
+/**
+ * Real-octopus tentacle count used by the continuous lower mesh.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+const OCTOPUS_TENTACLE_COUNT = 8;
+/**
+ * Octopus 3D 3 avatar visual.
+ *
+ * @private built-in avatar visual
+ */
+const octopus3d3AvatarVisual = {
+    id: 'octopus3d3',
+    title: 'Octopus 3D 3',
+    description: 'Cute continuous 3D octopus with a blobby single mesh, waving tentacle lobes, rich shading, and cursor-aware eyes.',
+    isAnimated: true,
+    supportsPointerTracking: true,
+    render({ context, size, palette, createRandom, timeMs, interaction }) {
+        const morphologyProfile = createOctopus3MorphologyProfile(createRandom);
+        const animationRandom = createRandom('octopus3d3-animation-profile');
+        const eyeRandom = createRandom('octopus3d3-eye-profile');
+        const animationPhase = animationRandom() * Math.PI * 2;
+        const tentacleProfiles = createContinuousTentacleProfiles(createRandom, morphologyProfile);
+        const sceneCenterX = size * 0.5;
+        const sceneCenterY = size * 0.535;
+        const bob = Math.sin(timeMs / 960 + animationPhase) * size * 0.012;
+        const meshCenter = {
+            x: interaction.bodyOffsetX * size * 0.048 + size * morphologyProfile.body.centerXJitterRatio * 0.44,
+            y: -size * 0.07 + interaction.bodyOffsetY * size * 0.026 + bob,
+            z: interaction.intensity * size * 0.018,
+        };
+        const rotationY = -0.1 +
+            Math.sin(timeMs / 2700 + animationPhase) * 0.035 +
+            interaction.bodyOffsetX * 0.22 +
+            interaction.gazeX * 0.88;
+        const rotationX = -0.07 +
+            Math.cos(timeMs / 3100 + animationPhase * 0.7) * 0.018 -
+            interaction.bodyOffsetY * 0.08 -
+            interaction.gazeY * 0.38;
+        const surfaceOptions = {
+            radiusX: size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.horizontalStretch * 1.1,
+            radiusY: size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.verticalStretch * 1.08,
+            radiusZ: size *
+                morphologyProfile.body.bodyRadiusRatio *
+                (1.02 + (morphologyProfile.body.horizontalStretch - 1) * 0.18),
+            morphologyProfile,
+            timeMs,
+            animationPhase,
+            tentacleProfiles,
+        };
+        const surfacePatches = resolveVisibleContinuousOctopusPatches({
+            ...surfaceOptions,
+            center: meshCenter,
+            rotationX,
+            rotationY,
+            sceneCenterX,
+            sceneCenterY,
+            size,
+            palette,
+        });
+        const eyeLatitude = clampNumber$1(morphologyProfile.face.eyeCenterYOffsetRatio * 4.2 - 0.03, -0.22, 0.08);
+        const eyeLongitude = clampNumber$1(morphologyProfile.face.eyeSpacingRatio * 3.1, 0.18, 0.32);
+        const mouthLatitude = clampNumber$1(eyeLatitude + 0.2 + morphologyProfile.face.mouthYOffsetRatio, 0.08, 0.34);
+        const mouthCenterLongitude = clampNumber$1(morphologyProfile.face.mouthCenterOffsetRatio * 5.6, -0.08, 0.08);
+        const mouthHalfLongitude = clampNumber$1(eyeLongitude * 0.78, 0.15, 0.28);
+        const mouthCurveLatitude = clampNumber$1(mouthLatitude + morphologyProfile.face.mouthCurveDepthRatio * 0.78, mouthLatitude + 0.03, 0.42);
+        const eyeRadiusX = size * morphologyProfile.face.eyeRadiusXRatio * 0.76;
+        const eyeRadiusY = eyeRadiusX * morphologyProfile.face.eyeHeightRatio * 0.9;
+        drawAvatarFrame(context, size, palette);
+        drawContinuousOctopusAtmosphere(context, size, palette, sceneCenterX, sceneCenterY, interaction, timeMs);
+        drawContinuousOctopusShadow(context, size, palette, interaction, timeMs, morphologyProfile);
+        for (const surfacePatch of surfacePatches.sort((firstSurfacePatch, secondSurfacePatch) => firstSurfacePatch.averageDepth - secondSurfacePatch.averageDepth)) {
+            drawContinuousSurfacePatch(context, surfacePatch);
+        }
+        drawProjectedSurfaceCurrents({
+            context,
+            surfaceOptions,
+            center: meshCenter,
+            rotationX,
+            rotationY,
+            sceneCenterX,
+            sceneCenterY,
+            size,
+            palette,
+            morphologyProfile,
+            timeMs,
+            animationPhase,
+        });
+        drawProjectedTentacleSuckers({
+            context,
+            surfaceOptions,
+            center: meshCenter,
+            rotationX,
+            rotationY,
+            sceneCenterX,
+            sceneCenterY,
+            size,
+            palette,
+        });
+        drawProjectedOrganicEye(context, sampleContinuousOctopusSurfacePoint(surfaceOptions, eyeLatitude, -eyeLongitude), eyeRadiusX, eyeRadiusY, meshCenter, rotationX, rotationY, sceneCenterX, sceneCenterY, size, palette, timeMs, animationPhase + eyeRandom() * 0.7, interaction, morphologyProfile.face.eyeStyle);
+        drawProjectedOrganicEye(context, sampleContinuousOctopusSurfacePoint(surfaceOptions, eyeLatitude, eyeLongitude), eyeRadiusX, eyeRadiusY, meshCenter, rotationX, rotationY, sceneCenterX, sceneCenterY, size, palette, timeMs, animationPhase + 0.85 + eyeRandom() * 0.7, interaction, morphologyProfile.face.eyeStyle);
+        drawProjectedOrganicMouth(context, [
+            sampleContinuousOctopusSurfacePoint(surfaceOptions, mouthLatitude, mouthCenterLongitude - mouthHalfLongitude),
+            sampleContinuousOctopusSurfacePoint(surfaceOptions, mouthCurveLatitude, mouthCenterLongitude),
+            sampleContinuousOctopusSurfacePoint(surfaceOptions, mouthLatitude, mouthCenterLongitude + mouthHalfLongitude),
+        ], meshCenter, rotationX, rotationY, sceneCenterX, sceneCenterY, palette, size);
+    },
+};
+/**
+ * Creates seeded tentacle-lobe profiles around the visible lower octopus body.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function createContinuousTentacleProfiles(createRandom, morphologyProfile) {
+    return Array.from({ length: OCTOPUS_TENTACLE_COUNT }, (_, tentacleIndex) => {
+        const tentacleRandom = createRandom(`octopus3d3-tentacle-${tentacleIndex}`);
+        const progress = tentacleIndex / (OCTOPUS_TENTACLE_COUNT - 1);
+        return {
+            centerLongitude: -Math.PI * 0.86 +
+                progress * Math.PI * 1.72 +
+                (tentacleRandom() - 0.5) * (0.08 + morphologyProfile.tentacles.rootSpreadScale * 0.03),
+            widthScale: 0.86 + tentacleRandom() * 0.34 + (morphologyProfile.tentacles.baseWidthScale - 1) * 0.16,
+            lengthScale: 0.86 + tentacleRandom() * 0.36 + (morphologyProfile.tentacles.flowLengthScale - 1) * 0.22,
+            swayScale: 0.82 + tentacleRandom() * 0.38 + (morphologyProfile.tentacles.swayScale - 1) * 0.2,
+            depthScale: 0.86 + tentacleRandom() * 0.32 + (morphologyProfile.tentacles.tipReachScale - 1) * 0.2,
+            phase: tentacleRandom() * Math.PI * 2,
+            suckerSide: tentacleRandom() > 0.5 ? 1 : -1,
+        };
+    });
+}
+/**
+ * Draws the soft underwater atmosphere behind the continuous octopus mesh.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function drawContinuousOctopusAtmosphere(context, size, palette, sceneCenterX, sceneCenterY, interaction, timeMs) {
+    const glowGradient = context.createRadialGradient(sceneCenterX + interaction.gazeX * size * 0.11, sceneCenterY - size * 0.17 + interaction.gazeY * size * 0.05, size * 0.04, sceneCenterX, sceneCenterY, size * (0.66 + interaction.intensity * 0.02));
+    glowGradient.addColorStop(0, `${palette.highlight}66`);
+    glowGradient.addColorStop(0.34, `${palette.accent}2e`);
+    glowGradient.addColorStop(1, `${palette.highlight}00`);
+    context.fillStyle = glowGradient;
+    context.fillRect(0, 0, size, size);
+    const lowerGradient = context.createRadialGradient(sceneCenterX + Math.sin(timeMs / 1550) * size * 0.05, sceneCenterY + size * 0.29, size * 0.06, sceneCenterX, sceneCenterY + size * 0.3, size * 0.54);
+    lowerGradient.addColorStop(0, `${palette.secondary}25`);
+    lowerGradient.addColorStop(1, `${palette.secondary}00`);
+    context.fillStyle = lowerGradient;
+    context.fillRect(0, 0, size, size);
+}
+/**
+ * Draws the soft lower shadow that anchors the octopus in the avatar frame.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function drawContinuousOctopusShadow(context, size, palette, interaction, timeMs, morphologyProfile) {
+    context.save();
+    context.fillStyle = `${palette.shadow}66`;
+    context.filter = `blur(${size * 0.025}px)`;
+    context.beginPath();
+    context.ellipse(size * 0.5 + interaction.gazeX * size * 0.045, size * 0.9 + Math.sin(timeMs / 980) * size * 0.007, size * (0.19 + morphologyProfile.tentacles.rootSpreadScale * 0.022 + interaction.intensity * 0.02), size * 0.06, 0, 0, Math.PI * 2);
+    context.fill();
+    context.restore();
+}
+/**
+ * Resolves visible projected patches for the continuous octopus mesh.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function resolveVisibleContinuousOctopusPatches(options) {
+    const { center, rotationX, rotationY, sceneCenterX, sceneCenterY, size, palette } = options;
+    const latitudePatchCount = 16;
+    const longitudePatchCount = 40;
+    const surfacePatches = [];
+    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 centerLatitude = (startLatitude + endLatitude) / 2;
+        const verticalProgress = (Math.sin(centerLatitude) + 1) / 2;
+        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 = 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);
+            surfacePatches.push({
+                corners: projectedCorners,
+                averageDepth: transformedCorners.reduce((depthSum, transformedCorner) => depthSum + transformedCorner.z, 0) /
+                    transformedCorners.length,
+                lightIntensity: clampNumber$1(dotProduct3D(surfaceNormal, LIGHT_DIRECTION), -1, 1),
+                fillStyle: resolveContinuousSurfacePatchFillStyle(palette, verticalProgress, Math.max(0, Math.cos(centerLongitude)), tentacleInfluence.core, lowerLobeWave),
+                outlineColor: verticalProgress < 0.54 ? `${palette.highlight}69` : `${palette.shadow}78`,
+            });
+        }
+    }
+    return surfacePatches;
+}
+/**
+ * Samples one point on the continuous Octopus 3D 3 surface.
+ *
+ * The lower hemisphere is pulled into eight seeded waving lobes, so the portrait reads as
+ * tentacled while still being rendered as one connected blobby mesh.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function sampleContinuousOctopusSurfacePoint(options, latitude, longitude) {
+    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)) *
+        (0.018 + morphologyProfile.body.wobbleAmplitudeRatio * 0.8) *
+        (0.3 + lowerBlend * 0.7);
+    const tentacleWave = Math.sin(timeMs / 760 + tentacleInfluence.phase + verticalProgress * 2.4) *
+        lowerBlend *
+        tentacleInfluence.core *
+        tentacleInfluence.swayScale;
+    const horizontalScale = 1.04 +
+        mantleRipple +
+        lowerBlend * (0.16 + (morphologyProfile.tentacles.rootSpreadScale - 1) * 0.1) +
+        lowerBlend * tentacleInfluence.core * (0.2 + lowerLobeWave * 0.12) -
+        upperBlend * 0.08;
+    const depthScale = 1.06 +
+        upperBlend * 0.16 +
+        Math.max(0, Math.cos(effectiveLongitude)) * 0.1 +
+        lowerBlend * tentacleInfluence.core * (0.1 + tentacleInfluence.depthScale * 0.06) -
+        Math.max(0, -Math.cos(effectiveLongitude)) * 0.05;
+    const tentacleTubeRadius = lowerBlend *
+        tentacleInfluence.core *
+        (0.11 + tipBlend * 0.06 + tentacleInfluence.widthScale * 0.025) *
+        radiusX;
+    const planarRadiusX = cosineLatitude * radiusX * horizontalScale + tentacleTubeRadius;
+    const planarRadiusZ = cosineLatitude * radiusZ * depthScale + tentacleTubeRadius * 0.72;
+    const lowerDrop = lowerBlend *
+        radiusY *
+        (0.18 +
+            tentacleInfluence.core *
+                (0.38 +
+                    tentacleInfluence.lengthScale * 0.22 +
+                    (morphologyProfile.tentacles.flowLengthScale - 1) * 0.08));
+    return {
+        x: Math.sin(effectiveLongitude) * planarRadiusX +
+            tentacleWave * radiusX * (0.052 + tipBlend * 0.05),
+        y: Math.sin(latitude) * radiusY * (1 + upperBlend * 0.12) -
+            upperBlend * radiusY * 0.1 +
+            lowerDrop +
+            Math.sin(timeMs / 1420 + animationPhase + latitude * 1.6) * lowerBlend * radiusY * 0.018 +
+            Math.cos(timeMs / 880 + tentacleInfluence.phase) *
+                lowerBlend *
+                tipBlend *
+                tentacleInfluence.core *
+                radiusY *
+                0.034,
+        z: Math.cos(effectiveLongitude) * planarRadiusZ +
+            Math.cos(timeMs / 980 + tentacleInfluence.phase + verticalProgress) *
+                lowerBlend *
+                tentacleInfluence.core *
+                radiusZ *
+                0.04,
+    };
+}
+/**
+ * Blends nearby seeded tentacle profiles at one mesh longitude.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function resolveContinuousTentacleInfluence(options, longitude) {
+    let totalWeight = 0;
+    let weightedSin = 0;
+    let weightedCos = 0;
+    let weightedWidthScale = 0;
+    let weightedLengthScale = 0;
+    let weightedSwayScale = 0;
+    let weightedDepthScale = 0;
+    let weightedPhase = 0;
+    for (const tentacleProfile of options.tentacleProfiles) {
+        const distance = Math.abs(resolveSignedAngularDistance(longitude, tentacleProfile.centerLongitude));
+        const width = 0.2 * tentacleProfile.widthScale;
+        const weight = Math.exp(-(distance * distance) / (width * width));
+        totalWeight += weight;
+        weightedSin += Math.sin(tentacleProfile.centerLongitude) * weight;
+        weightedCos += Math.cos(tentacleProfile.centerLongitude) * weight;
+        weightedWidthScale += tentacleProfile.widthScale * weight;
+        weightedLengthScale += tentacleProfile.lengthScale * weight;
+        weightedSwayScale += tentacleProfile.swayScale * weight;
+        weightedDepthScale += tentacleProfile.depthScale * weight;
+        weightedPhase += tentacleProfile.phase * weight;
+    }
+    if (totalWeight < 0.0001) {
+        return {
+            core: 0,
+            centerLongitude: longitude,
+            widthScale: 1,
+            lengthScale: 1,
+            swayScale: 1,
+            depthScale: 1,
+            phase: 0,
+        };
+    }
+    return {
+        core: clampNumber$1(totalWeight, 0, 1),
+        centerLongitude: Math.atan2(weightedSin / totalWeight, weightedCos / totalWeight),
+        widthScale: weightedWidthScale / totalWeight,
+        lengthScale: weightedLengthScale / totalWeight,
+        swayScale: weightedSwayScale / totalWeight,
+        depthScale: weightedDepthScale / totalWeight,
+        phase: weightedPhase / totalWeight,
+    };
+}
+/**
+ * Resolves the soft lower wave that makes the continuous mesh read as a set of tentacles.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function resolveContinuousLobeWave(options, longitude) {
+    const { morphologyProfile, animationPhase, timeMs } = options;
+    return (Math.cos(longitude * OCTOPUS_TENTACLE_COUNT + animationPhase + timeMs / (980 + morphologyProfile.body.lobeCount * 18)) +
+        1) / 2;
+}
+/**
+ * Resolves one base fill tone for a patch on the continuous octopus mesh.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function resolveContinuousSurfacePatchFillStyle(palette, verticalProgress, forwardness, tentacleCore, lowerLobeWave) {
+    const tonalProgress = clampNumber$1(verticalProgress + lowerLobeWave * 0.1 + tentacleCore * 0.08 - forwardness * 0.08, 0, 1);
+    if (tonalProgress < 0.14) {
+        return palette.highlight;
+    }
+    if (tonalProgress < 0.32) {
+        return palette.secondary;
+    }
+    if (tonalProgress < 0.72) {
+        return forwardness > 0.55 ? palette.secondary : palette.primary;
+    }
+    return tentacleCore > 0.44 ? `${palette.primary}f4` : `${palette.shadow}ee`;
+}
+/**
+ * Draws one projected mesh patch with soft shading and a subtle edge.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function drawContinuousSurfacePatch(context, surfacePatch) {
+    drawProjectedQuad(context, surfacePatch.corners, surfacePatch.fillStyle);
+    if (surfacePatch.lightIntensity > 0) {
+        drawProjectedQuad(context, surfacePatch.corners, `rgba(255, 255, 255, ${0.18 * surfacePatch.lightIntensity})`);
+    }
+    else if (surfacePatch.lightIntensity < 0) {
+        drawProjectedQuad(context, surfacePatch.corners, `rgba(0, 0, 0, ${0.25 * Math.abs(surfacePatch.lightIntensity)})`);
+    }
+    context.save();
+    context.beginPath();
+    context.moveTo(surfacePatch.corners[0].x, surfacePatch.corners[0].y);
+    for (let cornerIndex = 1; cornerIndex < surfacePatch.corners.length; cornerIndex++) {
+        context.lineTo(surfacePatch.corners[cornerIndex].x, surfacePatch.corners[cornerIndex].y);
+    }
+    context.closePath();
+    context.strokeStyle = surfacePatch.outlineColor;
+    context.lineWidth = Math.max(0.7, getProjectedQuadPerimeter(surfacePatch.corners) * 0.0032);
+    context.lineJoin = 'round';
+    context.stroke();
+    context.restore();
+}
+/**
+ * Draws projected mantle-current lines on the front of the mesh.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function drawProjectedSurfaceCurrents(options) {
+    const { context, surfaceOptions, center, rotationX, rotationY, sceneCenterX, sceneCenterY, size, palette, morphologyProfile, timeMs, animationPhase, } = options;
+    const currentCount = Math.min(6, morphologyProfile.details.mantleCurrentCount);
+    const centerIndex = (currentCount - 1) / 2;
+    context.save();
+    context.lineCap = 'round';
+    context.lineJoin = 'round';
+    for (let currentIndex = 0; currentIndex < currentCount; currentIndex++) {
+        const baseLongitude = (currentIndex - centerIndex) * 0.15;
+        const projectedPoints = [];
+        for (let sampleIndex = 0; sampleIndex < 8; sampleIndex++) {
+            const progress = sampleIndex / 7;
+            const latitude = -0.46 + progress * 0.74;
+            const longitude = baseLongitude +
+                Math.sin(timeMs / 1160 + animationPhase + currentIndex * 0.7 + progress * 2) * 0.035;
+            const scenePoint = transformScenePoint(sampleContinuousOctopusSurfacePoint(surfaceOptions, latitude, longitude), center, rotationX, rotationY);
+            if (scenePoint.z > center.z - size * 0.016) {
+                projectedPoints.push(projectScenePoint(scenePoint, size, sceneCenterX, sceneCenterY));
+            }
+        }
+        if (projectedPoints.length < 3) {
+            continue;
+        }
+        context.beginPath();
+        context.moveTo(projectedPoints[0].x, projectedPoints[0].y);
+        for (const projectedPoint of projectedPoints.slice(1)) {
+            context.lineTo(projectedPoint.x, projectedPoint.y);
+        }
+        context.strokeStyle = currentIndex % 2 === 0 ? `${palette.highlight}3d` : `${palette.accent}33`;
+        context.lineWidth = size * (0.0055 + currentIndex * 0.00045);
+        context.stroke();
+    }
+    context.restore();
+}
+/**
+ * Draws small projected sucker highlights on the waving lower mesh lobes.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function drawProjectedTentacleSuckers(options) {
+    const { surfaceOptions, size } = options;
+    const { timeMs } = surfaceOptions;
+    for (const tentacleProfile of surfaceOptions.tentacleProfiles) {
+        if (Math.cos(tentacleProfile.centerLongitude) < -0.12) {
+            continue;
+        }
+        for (let suckerIndex = 0; suckerIndex < 3; suckerIndex++) {
+            const latitude = 0.52 + suckerIndex * 0.14;
+            const sideOffset = tentacleProfile.suckerSide * (0.035 + suckerIndex * 0.012) * tentacleProfile.widthScale;
+            const waveOffset = Math.sin(timeMs / 900 + tentacleProfile.phase + suckerIndex * 0.8) * 0.018;
+            drawProjectedSurfaceSpot({
+                ...options,
+                latitude,
+                longitude: tentacleProfile.centerLongitude + sideOffset + waveOffset,
+                radiusScale: size * (0.0065 - suckerIndex * 0.0007),
+            });
+        }
+    }
+}
+/**
+ * Draws one tiny projected surface spot by sampling local mesh tangents.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function drawProjectedSurfaceSpot(options) {
+    const { context, surfaceOptions, center, rotationX, rotationY, sceneCenterX, sceneCenterY, size, palette, latitude, longitude, radiusScale, } = options;
+    const localCenter = sampleContinuousOctopusSurfacePoint(surfaceOptions, latitude, longitude);
+    const localHorizontal = sampleContinuousOctopusSurfacePoint(surfaceOptions, latitude, longitude + 0.018);
+    const localVertical = sampleContinuousOctopusSurfacePoint(surfaceOptions, latitude + 0.018, longitude);
+    const sceneCenterPoint = transformScenePoint(localCenter, center, rotationX, rotationY);
+    if (sceneCenterPoint.z <= center.z - size * 0.012) {
+        return;
+    }
+    const projectedCenterPoint = projectScenePoint(sceneCenterPoint, size, sceneCenterX, sceneCenterY);
+    const projectedHorizontalPoint = projectScenePoint(transformScenePoint(localHorizontal, center, rotationX, rotationY), size, sceneCenterX, sceneCenterY);
+    const projectedVerticalPoint = projectScenePoint(transformScenePoint(localVertical, center, rotationX, rotationY), size, sceneCenterX, sceneCenterY);
+    const horizontalRadius = clampNumber$1(Math.hypot(projectedHorizontalPoint.x - projectedCenterPoint.x, projectedHorizontalPoint.y - projectedCenterPoint.y) *
+        radiusScale *
+        0.74, size * 0.003, size * 0.018);
+    const verticalRadius = clampNumber$1(Math.hypot(projectedVerticalPoint.x - projectedCenterPoint.x, projectedVerticalPoint.y - projectedCenterPoint.y) *
+        radiusScale *
+        0.52, size * 0.0024, size * 0.014);
+    const rotation = Math.atan2(projectedHorizontalPoint.y - projectedCenterPoint.y, projectedHorizontalPoint.x - projectedCenterPoint.x);
+    context.save();
+    context.translate(projectedCenterPoint.x, projectedCenterPoint.y);
+    context.rotate(rotation);
+    context.beginPath();
+    context.ellipse(0, 0, horizontalRadius, verticalRadius, 0, 0, Math.PI * 2);
+    context.fillStyle = `${palette.highlight}73`;
+    context.fill();
+    context.strokeStyle = `${palette.highlight}99`;
+    context.lineWidth = Math.max(0.7, size * 0.0028);
+    context.stroke();
+    context.restore();
+}
+/**
+ * Resolves a signed angular distance from the source longitude to the target longitude.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function resolveSignedAngularDistance(sourceLongitude, targetLongitude) {
+    return Math.atan2(Math.sin(targetLongitude - sourceLongitude), Math.cos(targetLongitude - sourceLongitude));
+}
+/**
+ * Smoothly maps a value between two bounds into `[0, 1]`.
+ *
+ * @private helper of `octopus3d3AvatarVisual`
+ */
+function smoothStep(edgeStart, edgeEnd, value) {
+    const progress = clampNumber$1((value - edgeStart) / (edgeEnd - edgeStart), 0, 1);
+    return progress * progress * (3 - 2 * progress);
+}
+
 /* eslint-disable no-magic-numbers */
 /**
  * Octopus avatar visual.
@@ -13826,6 +14372,7 @@ const AVATAR_VISUALS = [
     octopus3AvatarVisual,
     octopus3dAvatarVisual,
     octopus3d2AvatarVisual,
+    octopus3d3AvatarVisual,
     asciiOctopusAvatarVisual,
     minecraftAvatarVisual,
     minecraft2AvatarVisual,
@@ -33837,6 +34384,14 @@ const CODEX_COMPLETION_LINE = /^\s*tokens used\b/i;
  * Idle timeout after completion marker to capture trailing output.
  */
 const CODEX_COMPLETION_IDLE_MS = 60 * 1000;
+/**
+ * Number of seconds in one hour.
+ */
+const SECONDS_PER_HOUR = 60 * 60;
+/**
+ * Poll interval used while waiting for the next rate-limit retry so pause requests can be honored promptly.
+ */
+const RATE_LIMIT_BACKOFF_POLL_MS = 1000;
 /**
  * Maximum delay between retries while rate-limited.
  */
@@ -33856,8 +34411,8 @@ async function waitFor(delayMs) {
  */
 function formatDelay(delayMs) {
     const totalSeconds = Math.max(0, Math.round(delayMs / 1000));
-    const hours = Math.floor(totalSeconds / 3600);
-    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);
+    const minutes = Math.floor((totalSeconds % SECONDS_PER_HOUR) / 60);
     const seconds = totalSeconds % 60;
     const parts = [];
     if (hours > 0) {
@@ -33898,6 +34453,7 @@ class OpenAiCodexRunner {
      * Runs the Codex prompt in a temporary script and waits for completion output.
      */
     async runPrompt(options) {
+        var _a;
         const scriptContent = buildCodexScript({
             prompt: options.prompt,
             projectPath: options.projectPath,
@@ -33908,7 +34464,14 @@ class OpenAiCodexRunner {
             allowCredits: this.options.allowCredits,
             codexCommand: this.options.codexCommand,
         });
-        while (true) {
+        for (let retryIndex = 0;; retryIndex++) {
+            if (retryIndex > 0) {
+                await ((_a = options.waitForPauseCheckpoint) === null || _a === void 0 ? void 0 : _a.call(options, {
+                    checkpointLabel: 'retrying the OpenAI Codex model call after rate limit',
+                    phase: 'running',
+                    statusMessage: 'Retrying OpenAI Codex after rate limit',
+                }));
+            }
             try {
                 const output = await $runGoScriptUntilMarkerIdle({
                     scriptPath: options.scriptPath,
@@ -33935,11 +34498,29 @@ class OpenAiCodexRunner {
                 const retryIndex = this.rateLimitBackoff.retryCount;
                 const summary = extractFailureSummary(details);
                 console.warn(colors.yellow(`[codex] Rate limit/quota detected (${summary}). Retry #${retryIndex} in ${formatDelay(delayMs)} at ${retryAt}.`));
-                await waitFor(delayMs);
+                await waitForRetryDelay(delayMs, options);
             }
         }
     }
 }
+/**
+ * Waits for the next Codex retry while polling for requested pause checkpoints.
+ */
+async function waitForRetryDelay(delayMs, options) {
+    var _a;
+    let remainingDelayMs = delayMs;
+    while (remainingDelayMs > 0) {
+        const remainingDelayLabel = formatDelay(remainingDelayMs);
+        await ((_a = options.waitForPauseCheckpoint) === null || _a === void 0 ? void 0 : _a.call(options, {
+            checkpointLabel: 'the next OpenAI Codex retry after rate limit',
+            phase: 'running',
+            statusMessage: `Waiting ${remainingDelayLabel} before retrying OpenAI Codex`,
+        }));
+        const currentDelayMs = Math.min(RATE_LIMIT_BACKOFF_POLL_MS, remainingDelayMs);
+        await waitFor(currentDelayMs);
+        remainingDelayMs -= currentDelayMs;
+    }
+}
 
 /**
  * Builds the shell script that runs Opencode with the prompt and coding context.
@@ -34260,6 +34841,10 @@ const MAX_PROMPT_TEST_ATTEMPTS = 3;
  * Maximum amount of verification output sent back to the coding agent as retry feedback.
  */
 const MAX_TEST_FEEDBACK_OUTPUT_CHARS = 12000;
+/**
+ * File extension used by generated shell scripts.
+ */
+const SHELL_SCRIPT_EXTENSION = '.sh';
 /**
  * Runs one coding prompt and, when configured, verifies it with a shell command that can feed failures back.
  */
@@ -34268,12 +34853,14 @@ async function runPromptWithTestFeedback(options) {
     const normalizedTestCommand = (_a = options.testCommand) === null || _a === void 0 ? void 0 : _a.trim();
     if (!normalizedTestCommand) {
         (_b = options.onAttemptStarted) === null || _b === void 0 ? void 0 : _b.call(options, 1);
+        await waitForPromptAttemptPauseCheckpoint(options.waitForPauseCheckpoint, options.runner.name, 1);
         const result = await options.runner.runPrompt({
             prompt: options.prompt,
             scriptPath: options.scriptPath,
             projectPath: options.projectPath,
             logPath: options.logPath,
             preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
+            waitForPauseCheckpoint: options.waitForPauseCheckpoint,
         });
         return { ...result, attemptCount: 1 };
     }
@@ -34281,13 +34868,16 @@ async function runPromptWithTestFeedback(options) {
     let promptForCurrentAttempt = options.prompt;
     for (let attemptCount = 1; attemptCount <= MAX_PROMPT_TEST_ATTEMPTS; attemptCount++) {
         (_d = options.onAttemptStarted) === null || _d === void 0 ? void 0 : _d.call(options, attemptCount);
+        await waitForPromptAttemptPauseCheckpoint(options.waitForPauseCheckpoint, options.runner.name, attemptCount);
         const result = await options.runner.runPrompt({
             prompt: promptForCurrentAttempt,
             scriptPath: options.scriptPath,
             projectPath: options.projectPath,
             logPath: options.logPath,
             preserveArtifactsOnSuccess: options.preserveArtifactsOnSuccess,
+            waitForPauseCheckpoint: options.waitForPauseCheckpoint,
         });
+        await waitForVerificationPauseCheckpoint(options.waitForPauseCheckpoint, normalizedTestCommand, attemptCount);
         console.info(colors.gray(`Running verification command after attempt #${attemptCount}: ${normalizedTestCommand}`));
         try {
             await runPromptTestCommandExecutor({
@@ -34321,6 +34911,44 @@ async function runPromptWithTestFeedback(options) {
     }
     throw new Error('Unexpected prompt verification state.');
 }
+/**
+ * Waits for a pause checkpoint immediately before one model attempt begins.
+ */
+async function waitForPromptAttemptPauseCheckpoint(waitForPauseCheckpoint, runnerName, attemptCount) {
+    await (waitForPauseCheckpoint === null || waitForPauseCheckpoint === void 0 ? void 0 : waitForPauseCheckpoint({
+        checkpointLabel: buildPromptAttemptPauseLabel(runnerName, attemptCount),
+        phase: 'running',
+        statusMessage: buildPromptAttemptStatusMessage(runnerName, attemptCount),
+    }));
+}
+/**
+ * Waits for a pause checkpoint immediately before one verification command begins.
+ */
+async function waitForVerificationPauseCheckpoint(waitForPauseCheckpoint, testCommand, attemptCount) {
+    await (waitForPauseCheckpoint === null || waitForPauseCheckpoint === void 0 ? void 0 : waitForPauseCheckpoint({
+        checkpointLabel: buildVerificationPauseLabel(attemptCount),
+        phase: 'verifying',
+        statusMessage: `Running verification after attempt #${attemptCount}: ${testCommand}`,
+    }));
+}
+/**
+ * Builds the human-readable pause label used before one runner attempt begins.
+ */
+function buildPromptAttemptPauseLabel(runnerName, attemptCount) {
+    return `calling ${runnerName} (attempt ${attemptCount})`;
+}
+/**
+ * Builds the status line shown while one runner attempt is about to start.
+ */
+function buildPromptAttemptStatusMessage(runnerName, attemptCount) {
+    return `Calling ${runnerName} (attempt ${attemptCount})`;
+}
+/**
+ * Builds the human-readable pause label used before one verification command begins.
+ */
+function buildVerificationPauseLabel(attemptCount) {
+    return `running verification after attempt #${attemptCount}`;
+}
 /**
  * Builds one feedback block appended to the next coding attempt after tests fail.
  */
@@ -34370,8 +34998,8 @@ function limitVerificationOutputForFeedback(verificationOutput) {
  * Derives a dedicated temp-script path for verification commands.
  */
 function buildPromptTestScriptPath(scriptPath) {
-    if (scriptPath.toLowerCase().endsWith('.sh')) {
-        return `${scriptPath.slice(0, -3)}.test.sh`;
+    if (scriptPath.toLowerCase().endsWith(SHELL_SCRIPT_EXTENSION)) {
+        return `${scriptPath.slice(0, -SHELL_SCRIPT_EXTENSION.length)}.test.sh`;
     }
     return `${scriptPath}.test.sh`;
 }
@@ -34562,7 +35190,7 @@ function buildAgentRunUiFrame(options) {
     const totalWidth = Math.max(MIN_FRAME_WIDTH, Math.min(options.terminalWidth, MAX_FRAME_WIDTH));
     const isPromptActive = options.phase === 'running' || options.phase === 'verifying' || options.phase === 'loading';
     const promptStatusPrefix = isPromptActive ? `${colors.yellow(`${options.spinner} `)}` : '';
-    const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.statusMessage);
+    const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.pauseTargetLabel, options.statusMessage);
     const sessionLines = buildSessionLines(options, totalWidth, pausePresentation);
     const agentStatusLines = buildAgentStatusTableLines(options, totalWidth);
     const currentTaskLines = options.currentPromptLabel
@@ -68802,8 +69430,12 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
     const commitMessage = buildCommitMessage(nextPrompt.file, nextPrompt.section);
     const codexPrompt = appendCoderContext(buildCodexPrompt(nextPrompt.file, nextPrompt.section), resolvedCoderContext);
     const scriptPath = buildScriptPath(nextPrompt.file, nextPrompt.section);
-    await waitForRequestedPause();
     setPromptRoundRunningState({ isRichUiEnabled, promptLabel, scriptPath, uiHandle });
+    await waitForRequestedPause({
+        checkpointLabel: 'preparing the current prompt execution',
+        phase: 'running',
+        statusMessage: 'Preparing prompt execution',
+    });
     const promptExecutionStartedDate = moment();
     let attemptCount = 1;
     const roundChangedFilesSnapshot = options.normalizeLineEndings
@@ -68824,11 +69456,8 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
                 onAttemptStarted: (nextAttemptCount) => {
                     attemptCount = nextAttemptCount;
                     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setAttempt(nextAttemptCount);
-                    if (nextAttemptCount > 1) {
-                        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`Retrying (attempt ${nextAttemptCount})`);
-                        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('verifying');
-                    }
                 },
+                waitForPauseCheckpoint: waitForRequestedPause,
             });
             await finalizeSuccessfulPromptRound({
                 options,
@@ -68842,6 +69471,7 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
                 isRichUiEnabled,
                 progressDisplay,
                 uiHandle,
+                waitForRequestedPause,
             });
         }
         catch (error) {
@@ -68854,6 +69484,7 @@ async function runPromptRound({ options, runner, runnerMetadata, nextPrompt, pro
                 options,
                 roundChangedFilesSnapshot,
                 uiHandle,
+                waitForRequestedPause,
             });
             throw error;
         }
@@ -68877,9 +69508,13 @@ function setPromptRoundRunningState(options) {
  * Finalizes a successful prompt round, including prompt bookkeeping and commit flow.
  */
 async function finalizeSuccessfulPromptRound(options) {
-    const { options: runOptions, nextPrompt, runnerMetadata, promptExecutionStartedDate, result, commitMessage, logPath, roundChangedFilesSnapshot, isRichUiEnabled, progressDisplay, uiHandle, } = options;
+    const { options: runOptions, nextPrompt, runnerMetadata, promptExecutionStartedDate, result, commitMessage, logPath, roundChangedFilesSnapshot, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, } = options;
     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.stopCapturingAgentOutput();
-    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(runOptions.noCommit ? 'Leaving changes uncommitted' : 'Committing changes');
+    await waitForRequestedPause({
+        checkpointLabel: 'recording the successful prompt result',
+        phase: 'running',
+        statusMessage: 'Recording prompt result',
+    });
     markPromptDone(nextPrompt.file, nextPrompt.section, result.usage, runnerMetadata.runnerName, runnerMetadata.modelName, promptExecutionStartedDate, result.attemptCount);
     await writePromptFile(nextPrompt.file);
     await normalizeLineEndingsForCurrentRound(runOptions, roundChangedFilesSnapshot);
@@ -68891,22 +69526,42 @@ async function finalizeSuccessfulPromptRound(options) {
             progressDisplay,
             uiHandle,
         });
+        await waitForRequestedPause({
+            checkpointLabel: 'committing the successful changes',
+            phase: 'running',
+            statusMessage: 'Committing changes',
+        });
         await commitChanges(commitMessage, {
             autoPush: runOptions.autoPush,
             // Keep the live runtime log out of default commits because it is deleted after a successful round.
             excludePaths: runOptions.preserveLogs ? undefined : [logPath],
         });
     }
+    else {
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Leaving changes uncommitted');
+    }
+    if (runOptions.autoMigrate) {
+        await waitForRequestedPause({
+            checkpointLabel: 'running testing-server auto-migration',
+            phase: 'running',
+            statusMessage: 'Running testing-server auto-migration',
+        });
+    }
     await runPostPromptAutoMigrationIfEnabled(runOptions);
 }
 /**
  * Finalizes a failed prompt round, persisting prompt failure metadata before rethrowing.
  */
 async function finalizeFailedPromptRound(options) {
-    const { nextPrompt, runnerMetadata, promptExecutionStartedDate, attemptCount, error, options: runOptions, roundChangedFilesSnapshot, uiHandle, } = options;
+    const { nextPrompt, runnerMetadata, promptExecutionStartedDate, attemptCount, error, options: runOptions, roundChangedFilesSnapshot, uiHandle, waitForRequestedPause, } = options;
     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.stopCapturingAgentOutput();
     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('error');
     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.addError(error instanceof Error ? error.message : String(error));
+    await waitForRequestedPause({
+        checkpointLabel: 'recording the prompt failure',
+        phase: 'error',
+        statusMessage: 'Recording prompt failure',
+    });
     markPromptFailed(nextPrompt.file, nextPrompt.section, runnerMetadata.runnerName, runnerMetadata.modelName, promptExecutionStartedDate, attemptCount);
     await writePromptFile(nextPrompt.file);
     await writePromptErrorLog({
@@ -68941,6 +69596,8 @@ async function waitForCommitConfirmationIfNeeded(options) {
     }
     progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
+    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('running');
+    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Committing changes');
 }
 /**
  * Formats commit preview lines for the rich terminal UI.
@@ -69013,11 +69670,21 @@ async function runCodexPrompts(providedOptions) {
         let hasShownUpcomingTasks = false;
         let hasWaitedForStart = false;
         while (just(true)) {
-            await waitForRequestedPause();
+            if (options.autoPull && !options.dryRun) {
+                await waitForRequestedPause({
+                    checkpointLabel: 'pulling the latest repository changes',
+                    phase: 'loading',
+                    statusMessage: 'Pulling latest changes...',
+                });
+            }
             await pullLatestChangesIfEnabled({
                 options,
                 isRichUiEnabled,
-                uiHandle,
+            });
+            await waitForRequestedPause({
+                checkpointLabel: 'loading prompts',
+                phase: 'loading',
+                statusMessage: 'Loading prompts...',
             });
             const promptQueueSnapshot = await loadPromptQueueSnapshot({
                 options,
@@ -69047,6 +69714,11 @@ async function runCodexPrompts(providedOptions) {
                 uiHandle,
             });
             if (!options.ignoreGitChanges) {
+                await waitForRequestedPause({
+                    checkpointLabel: 'checking the git working tree',
+                    phase: 'loading',
+                    statusMessage: 'Checking the working tree...',
+                });
                 await ensureWorkingTreeClean();
             }
             await runPromptRound({
@@ -69095,12 +69767,10 @@ function validateRunCodexPromptOptions(options) {
  * Pulls the latest repository state before loading prompts when the feature is enabled.
  */
 async function pullLatestChangesIfEnabled(options) {
-    const { options: runOptions, isRichUiEnabled, uiHandle } = options;
+    const { options: runOptions, isRichUiEnabled } = options;
     if (!runOptions.autoPull || runOptions.dryRun) {
         return;
     }
-    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('loading');
-    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Pulling latest changes...');
     if (!isRichUiEnabled) {
         console.info(colors.gray('Pulling latest changes before the next prompt...'));
     }
@@ -69124,22 +69794,26 @@ function createRunDisplays(options, runStartDate) {
  */
 function createPauseWaiter(options) {
     const { isRichUiEnabled, progressDisplay, uiHandle } = options;
-    return async () => {
+    return async (checkpoint) => {
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase(checkpoint.phase);
+        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(checkpoint.statusMessage);
+        announcePauseTargetLabel(checkpoint.checkpointLabel);
         await checkPause({
             silent: isRichUiEnabled,
             onPaused: () => {
                 progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.pauseTimer();
                 uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.pauseTimer();
                 uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('paused');
-                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Paused');
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(`Paused before ${checkpoint.checkpointLabel}`);
             },
             onResumed: () => {
                 progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
                 uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
-                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('loading');
-                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Resuming...');
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase(checkpoint.phase);
+                uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage(checkpoint.statusMessage);
             },
         });
+        resetPauseTargetLabel();
     };
 }
 /**
@@ -69184,11 +69858,7 @@ function initializeRunUi(uiHandle, runnerName, actualRunnerModel, options) {
  */
 async function loadPromptQueueSnapshot(options) {
     const { options: runOptions, isRichUiEnabled, progressDisplay, uiHandle } = options;
-    if (isRichUiEnabled) {
-        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentScriptPath(undefined);
-        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('loading');
-        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Loading prompts...');
-    }
+    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentScriptPath(undefined);
     const promptFiles = await loadPromptFiles(PROMPTS_DIR$1);
     const stats = summarizePrompts(promptFiles, runOptions.priority);
     progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.update(stats);