@promptbook/cli 0.112.0-65 → 0.112.0-66

package/umd/index.umd.js

@@ -60,7 +60,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-65';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-66';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -993,6 +993,45 @@
     }
     // TODO: Maybe implement by mix+hsl
 
+    /**
+     * Relative directory name without the `./` prefix for Git ignore rules and glob patterns.
+     *
+     * @private internal utility for Promptbook-owned temp files
+     */
+    const PROMPTBOOK_TEMP_DIRECTORY_NAME = '.promptbook';
+    /**
+     * Builds one project-relative path inside the shared Promptbook working directory.
+     *
+     * @private internal utility for Promptbook-owned temp files
+     */
+    function getPromptbookTempPath(...pathSegments) {
+        return `./${getPromptbookTempPosixPath(...pathSegments)}`;
+    }
+    /**
+     * Builds one absolute filesystem path inside the shared Promptbook working directory for a project root.
+     *
+     * @private internal utility for Promptbook-owned temp files
+     */
+    function resolvePromptbookTempPath(projectPath, ...pathSegments) {
+        return path.join(projectPath, PROMPTBOOK_TEMP_DIRECTORY_NAME, ...pathSegments);
+    }
+    /**
+     * Builds one POSIX path fragment inside the shared Promptbook working directory for globs and generated text files.
+     *
+     * @private internal utility for Promptbook-owned temp files
+     */
+    function getPromptbookTempPosixPath(...pathSegments) {
+        return path.posix.join(PROMPTBOOK_TEMP_DIRECTORY_NAME, ...pathSegments);
+    }
+    /**
+     * Builds one rooted `.gitignore` rule targeting a path inside the shared Promptbook working directory.
+     *
+     * @private internal utility for Promptbook-owned temp files
+     */
+    function getPromptbookTempGitignoreRule(...pathSegments) {
+        return `/${getPromptbookTempPosixPath(...pathSegments)}`;
+    }
+
     /**
      * Returns the same value that is passed as argument.
      * No side effects.
@@ -1235,7 +1274,6 @@
      */
     const DEFAULT_AGENTS_DIRNAME = './agents';
     // <- TODO: [🕝] Make also `AGENTS_DIRNAME_ALTERNATIVES`
-    // TODO: Just `.promptbook` in config, hardcode subfolders like `download-cache` or `execution-cache`
     /**
      * Where to store the temporary downloads
      *
@@ -1243,7 +1281,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    const DEFAULT_DOWNLOAD_CACHE_DIRNAME = './.promptbook/download-cache';
+    const DEFAULT_DOWNLOAD_CACHE_DIRNAME = getPromptbookTempPath('download-cache');
     /**
      * Where to store the cache of executions for promptbook CLI
      *
@@ -1251,7 +1289,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    const DEFAULT_EXECUTION_CACHE_DIRNAME = './.promptbook/execution-cache';
+    const DEFAULT_EXECUTION_CACHE_DIRNAME = getPromptbookTempPath('execution-cache');
     /**
      * Where to store the scrape cache
      *
@@ -1259,7 +1297,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    const DEFAULT_SCRAPE_CACHE_DIRNAME = './.promptbook/scrape-cache';
+    const DEFAULT_SCRAPE_CACHE_DIRNAME = getPromptbookTempPath('scrape-cache');
     /**
      * Id of application for the CLI when using remote server
      *
@@ -2178,9 +2216,8 @@
         '**/.git/**',
         '**/.idea/**',
         '**/.vscode/**',
-        '**/.promptbook/**',
+        `**/${getPromptbookTempPosixPath()}/**`,
         '**/.next/**',
-        '**/.tmp/**',
         '**/tmp/**',
         '**/coverage/**',
         '**/dist/**',
@@ -3000,13 +3037,9 @@
      */
     const GITIGNORE_FILE_PATH = '.gitignore';
     /**
-     * Promptbook coder temp directory that should stay out of version control.
+     * Shared Promptbook working directory that should stay out of version control.
      */
-    const CODER_TEMP_GITIGNORE_RULE = '/.tmp';
-    /**
-     * Promptbook coder cache directory that should stay out of version control.
-     */
-    const CODER_CACHE_GITIGNORE_RULE = '/.promptbook/ptbk-coder';
+    const CODER_TEMP_GITIGNORE_RULE = getPromptbookTempGitignoreRule();
     /**
      * Promptbook coder environment file that should stay out of version control.
      */
@@ -3016,7 +3049,7 @@
      */
     const CODER_GITIGNORE_HEADER = '# Promptbook Coder';
     /**
-     * Ensures `.gitignore` contains the standalone Promptbook coder temp and cache entries.
+     * Ensures `.gitignore` contains the shared Promptbook working-directory entry.
      *
      * @private function of `initializeCoderProjectConfiguration`
      */
@@ -3035,7 +3068,7 @@
      * Returns the Promptbook coder gitignore rules that still need to be added.
      */
     function getMissingCoderGitignoreRules(gitignoreContent) {
-        const requiredRules = [CODER_TEMP_GITIGNORE_RULE, CODER_CACHE_GITIGNORE_RULE, CODER_ENV_GITIGNORE_RULE];
+        const requiredRules = [CODER_TEMP_GITIGNORE_RULE, CODER_ENV_GITIGNORE_RULE];
         return requiredRules.filter((rule) => !hasGitignoreRule(gitignoreContent, rule));
     }
     /**
@@ -22691,6 +22724,177 @@
         context.restore();
     }
 
+    /* eslint-disable no-magic-numbers */
+    /**
+     * Builds the seeded six-face texture pack used by the Minecraft-style head cuboid.
+     *
+     * @param random Seeded random generator.
+     * @param palette Derived avatar palette.
+     * @param hasHeadband Whether the generated avatar should include a colored headband.
+     * @returns Head cuboid textures.
+     *
+     * @private helper of the Minecraft avatar visuals
+     */
+    function createMinecraftHeadTextures(random, palette, hasHeadband) {
+        const faceTexture = createMinecraftFaceTexture(random, palette, hasHeadband);
+        const hairColor = random() < 0.5 ? palette.primary : palette.secondary;
+        const skinColor = palette.highlight;
+        const headbandColor = hasHeadband ? palette.accent : hairColor;
+        const sideTexture = createFilledTexture(skinColor);
+        const backTexture = createFilledTexture(skinColor);
+        const topTexture = createFilledTexture(hairColor);
+        const bottomTexture = createFilledTexture(`${palette.shadow}cc`);
+        fillTextureRect(sideTexture, 0, 0, 8, 3, hairColor);
+        fillTextureRect(backTexture, 0, 0, 8, 5, hairColor);
+        fillTextureRect(backTexture, 1, 5, 6, 1, hairColor);
+        if (hasHeadband) {
+            fillTextureRect(sideTexture, 0, 2, 8, 1, headbandColor);
+            fillTextureRect(backTexture, 0, 2, 8, 1, headbandColor);
+            fillTextureRect(topTexture, 0, 4, 8, 1, headbandColor);
+        }
+        sideTexture[4][4] = `${palette.shadow}99`;
+        sideTexture[5][4] = `${palette.shadow}cc`;
+        backTexture[6][2] = `${palette.shadow}99`;
+        backTexture[6][5] = `${palette.shadow}99`;
+        return {
+            front: faceTexture,
+            back: backTexture,
+            left: sideTexture,
+            right: mirrorMinecraftTexture(sideTexture),
+            top: topTexture,
+            bottom: bottomTexture,
+        };
+    }
+    /**
+     * Builds the seeded six-face texture pack used by the Minecraft-style torso cuboid.
+     *
+     * @param random Seeded random generator.
+     * @param palette Derived avatar palette.
+     * @returns Torso cuboid textures.
+     *
+     * @private helper of the Minecraft avatar visuals
+     */
+    function createMinecraftTorsoTextures(random, palette) {
+        const frontTexture = createMinecraftShirtTexture(random, palette);
+        const sideTexture = createFilledTexture(palette.primary);
+        const backTexture = createFilledTexture(palette.primary);
+        const topTexture = createFilledTexture(`${palette.highlight}dd`);
+        const bottomTexture = createFilledTexture(`${palette.shadow}dd`);
+        const stripeColor = random() < 0.5 ? palette.secondary : palette.highlight;
+        fillTextureRect(sideTexture, 0, 0, 8, 2, palette.shadow);
+        fillTextureRect(backTexture, 0, 0, 8, 2, palette.shadow);
+        fillTextureRect(backTexture, 3, 2, 2, 6, stripeColor);
+        fillTextureRect(sideTexture, 4, 2, 1, 6, stripeColor);
+        fillTextureRect(topTexture, 0, 0, 8, 2, palette.shadow);
+        fillTextureRect(topTexture, 2, 2, 4, 4, stripeColor);
+        return {
+            front: frontTexture,
+            back: backTexture,
+            left: sideTexture,
+            right: mirrorMinecraftTexture(sideTexture),
+            top: topTexture,
+            bottom: bottomTexture,
+        };
+    }
+    /**
+     * Mirrors one Minecraft texture horizontally.
+     *
+     * @param texture Source texture.
+     * @returns Mirrored texture copy.
+     *
+     * @private helper of the Minecraft avatar visuals
+     */
+    function mirrorMinecraftTexture(texture) {
+        return texture.map((row) => [...row].reverse());
+    }
+    /**
+     * Creates the front-face pixel texture for the cube head.
+     *
+     * @param random Seeded random generator.
+     * @param palette Derived avatar palette.
+     * @param hasHeadband Whether the avatar should render a headband row.
+     * @returns 8x8 pixel texture.
+     *
+     * @private helper of the Minecraft avatar visuals
+     */
+    function createMinecraftFaceTexture(random, palette, hasHeadband) {
+        const texture = createFilledTexture(palette.highlight);
+        const hairlineColor = random() < 0.5 ? palette.primary : palette.secondary;
+        const cheekColor = random() < 0.5 ? `${palette.accent}bb` : `${palette.secondary}bb`;
+        fillTextureRect(texture, 0, 0, 8, 2, hairlineColor);
+        texture[2][0] = hairlineColor;
+        texture[2][7] = hairlineColor;
+        texture[3][0] = hairlineColor;
+        texture[3][7] = hairlineColor;
+        if (hasHeadband) {
+            fillTextureRect(texture, 0, 2, 8, 1, palette.accent);
+        }
+        texture[3][2] = palette.ink;
+        texture[3][5] = palette.ink;
+        texture[4][2] = '#ffffff';
+        texture[4][5] = '#ffffff';
+        texture[5][1] = cheekColor;
+        texture[5][6] = cheekColor;
+        texture[5][3] = palette.shadow;
+        texture[5][4] = palette.shadow;
+        texture[6][3] = palette.shadow;
+        texture[6][4] = palette.shadow;
+        return texture;
+    }
+    /**
+     * Creates the front-face pixel texture for the torso.
+     *
+     * @param random Seeded random generator.
+     * @param palette Derived avatar palette.
+     * @returns 8x8 torso texture.
+     *
+     * @private helper of the Minecraft avatar visuals
+     */
+    function createMinecraftShirtTexture(random, palette) {
+        const texture = createFilledTexture(palette.primary);
+        const stripeColor = random() < 0.5 ? palette.secondary : palette.highlight;
+        fillTextureRect(texture, 0, 0, 8, 2, palette.shadow);
+        for (let rowIndex = 2; rowIndex < 8; rowIndex++) {
+            texture[rowIndex][3] = stripeColor;
+            texture[rowIndex][4] = stripeColor;
+        }
+        texture[4][1] = palette.accent;
+        texture[4][6] = palette.accent;
+        texture[5][2] = palette.highlight;
+        texture[5][5] = palette.highlight;
+        return texture;
+    }
+    /**
+     * Creates one solid-color 8x8 Minecraft texture.
+     *
+     * @param color Fill color.
+     * @returns Filled 8x8 texture.
+     *
+     * @private helper of the Minecraft avatar visuals
+     */
+    function createFilledTexture(color) {
+        return Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => color));
+    }
+    /**
+     * Fills one rectangular area inside a mutable Minecraft texture.
+     *
+     * @param texture Mutable target texture.
+     * @param x Left texture coordinate.
+     * @param y Top texture coordinate.
+     * @param width Rectangle width.
+     * @param height Rectangle height.
+     * @param color Fill color.
+     *
+     * @private helper of the Minecraft avatar visuals
+     */
+    function fillTextureRect(texture, x, y, width, height, color) {
+        for (let rowIndex = y; rowIndex < y + height; rowIndex++) {
+            for (let columnIndex = x; columnIndex < x + width; columnIndex++) {
+                texture[rowIndex][columnIndex] = color;
+            }
+        }
+    }
+
     /* eslint-disable no-magic-numbers */
     /**
      * Minecraft-style 3D avatar visual.
@@ -22715,8 +22919,8 @@
             const bodyX = size * 0.33;
             const bodyY = headY + headSize * 0.96;
             const hasHeadband = random() < 0.5;
-            const faceTexture = createMinecraftFaceTexture(createRandom('minecraft-face'), palette, hasHeadband);
-            const shirtTexture = createMinecraftShirtTexture(createRandom('minecraft-shirt'), palette);
+            const headTextures = createMinecraftHeadTextures(createRandom('minecraft-face'), palette, hasHeadband);
+            const torsoTextures = createMinecraftTorsoTextures(createRandom('minecraft-shirt'), palette);
             drawAvatarFrame(context, size, palette);
             const spotlight = context.createRadialGradient(size * 0.5, size * 0.18, size * 0.05, size * 0.5, size * 0.18, size * 0.5);
             spotlight.addColorStop(0, `${palette.highlight}66`);
@@ -22736,7 +22940,7 @@
                 width: bodyWidth,
                 height: bodyHeight,
                 depth: bodyDepth,
-                frontTexture: shirtTexture,
+                frontTexture: torsoTextures.front,
                 topColor: `${palette.highlight}cc`,
                 sideColor: `${palette.secondary}dd`,
                 outlineColor: `${palette.shadow}aa`,
@@ -22747,7 +22951,7 @@
                 width: headSize,
                 height: headSize,
                 depth,
-                frontTexture: faceTexture,
+                frontTexture: headTextures.front,
                 topColor: `${palette.highlight}ee`,
                 sideColor: `${palette.secondary}ee`,
                 outlineColor: `${palette.shadow}cc`,
@@ -22812,72 +23016,505 @@
         context.closePath();
         context.stroke();
     }
+
+    /* eslint-disable no-magic-numbers */
     /**
-     * Creates the front-face pixel texture for the cube head.
+     * Fixed scene camera distance used for the proper-3D projection.
      *
-     * @param random Seeded random generator.
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    const CAMERA_DISTANCE_RATIO = 1.4;
+    /**
+     * Shared light direction used to shade projected cuboid faces.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    const LIGHT_DIRECTION = normalizeVector3({
+        x: 0.4,
+        y: -0.65,
+        z: 0.92,
+    });
+    /**
+     * Minecraft 3D 2 avatar visual.
+     *
+     * @private built-in avatar visual
+     */
+    const minecraft2AvatarVisual = {
+        id: 'minecraft2',
+        title: 'Minecraft 3D 2',
+        description: 'Proper 3D Minecraft-style portrait with textured cuboids and pointer-driven head turns.',
+        isAnimated: true,
+        supportsPointerTracking: true,
+        render({ context, size, palette, createRandom, timeMs, interaction }) {
+            const spotlightY = size * 0.22;
+            const headRandom = createRandom('minecraft2-head');
+            const hasHeadband = headRandom() < 0.5;
+            const headTextures = createMinecraftHeadTextures(createRandom('minecraft2-head-textures'), palette, hasHeadband);
+            const torsoTextures = createMinecraftTorsoTextures(createRandom('minecraft2-body-textures'), palette);
+            const bob = Math.sin(timeMs / 880) * size * 0.014;
+            const bodyYaw = -0.24 + Math.sin(timeMs / 2300) * 0.06 + interaction.bodyOffsetX * 0.16;
+            const bodyPitch = -0.12 + Math.cos(timeMs / 2800) * 0.02 - interaction.bodyOffsetY * 0.06;
+            const headYaw = -0.18 + Math.sin(timeMs / 1900 + 0.6) * 0.05 + interaction.gazeX * 0.62;
+            const headPitch = -0.12 + Math.cos(timeMs / 2400 + 1.1) * 0.03 - interaction.gazeY * 0.38;
+            const sceneCenterX = size * 0.5;
+            const sceneCenterY = size * 0.57;
+            const bodyWidth = size * 0.225;
+            const bodyHeight = size * 0.245;
+            const bodyDepth = size * 0.145;
+            const headSize = size * 0.24;
+            const headLift = size * 0.205;
+            const headForwardShift = interaction.intensity * size * 0.018;
+            const sceneCuboids = [
+                {
+                    center: {
+                        x: interaction.bodyOffsetX * size * 0.026,
+                        y: size * 0.05 + interaction.bodyOffsetY * size * 0.018 + bob,
+                        z: 0,
+                    },
+                    width: bodyWidth,
+                    height: bodyHeight,
+                    depth: bodyDepth,
+                    rotationX: bodyPitch,
+                    rotationY: bodyYaw,
+                    textures: torsoTextures,
+                    outlineColor: `${palette.shadow}cc`,
+                },
+                {
+                    center: {
+                        x: interaction.bodyOffsetX * size * 0.018 + interaction.gazeX * size * 0.016,
+                        y: -headLift + bob * 1.15,
+                        z: headForwardShift,
+                    },
+                    width: headSize,
+                    height: headSize,
+                    depth: headSize,
+                    rotationX: headPitch,
+                    rotationY: headYaw,
+                    textures: headTextures,
+                    outlineColor: `${palette.shadow}dd`,
+                },
+            ];
+            const visibleFaces = sceneCuboids
+                .flatMap((cuboid) => resolveVisibleCuboidFaces(cuboid, size, sceneCenterX, sceneCenterY))
+                .sort((firstFace, secondFace) => firstFace.averageDepth - secondFace.averageDepth);
+            drawAvatarFrame(context, size, palette);
+            drawMinecraftBackdrop(context, size, palette, sceneCenterX, spotlightY, interaction, timeMs);
+            drawMinecraftShadow(context, size, palette, interaction, timeMs);
+            for (const visibleFace of visibleFaces) {
+                drawTexturedProjectedFace(context, visibleFace);
+            }
+        },
+    };
+    /**
+     * Draws the shared background atmosphere behind the Minecraft 3D 2 portrait.
+     *
+     * @param context Canvas 2D context.
+     * @param size Canvas size in CSS pixels.
      * @param palette Derived avatar palette.
-     * @param hasHeadband Whether the avatar should render a headband row.
-     * @returns 8x8 pixel texture.
+     * @param sceneCenterX Horizontal scene center.
+     * @param spotlightY Vertical spotlight anchor.
+     * @param interaction Smoothed pointer-aware interaction state.
+     * @param timeMs Current animation time in milliseconds.
      *
-     * @private helper of `minecraftAvatarVisual`
+     * @private helper of `minecraft2AvatarVisual`
      */
-    function createMinecraftFaceTexture(random, palette, hasHeadband) {
-        const texture = Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => palette.highlight));
-        const hairlineColor = random() < 0.5 ? palette.primary : palette.secondary;
-        const cheekColor = random() < 0.5 ? `${palette.accent}bb` : `${palette.secondary}bb`;
-        for (let rowIndex = 0; rowIndex < 2; rowIndex++) {
-            for (let columnIndex = 0; columnIndex < 8; columnIndex++) {
-                texture[rowIndex][columnIndex] = hairlineColor;
+    function drawMinecraftBackdrop(context, size, palette, sceneCenterX, spotlightY, interaction, timeMs) {
+        const spotlightGradient = context.createRadialGradient(sceneCenterX + interaction.gazeX * size * 0.08, spotlightY + interaction.gazeY * size * 0.05, size * 0.03, sceneCenterX, spotlightY, size * 0.52);
+        spotlightGradient.addColorStop(0, `${palette.highlight}66`);
+        spotlightGradient.addColorStop(0.42, `${palette.accent}1d`);
+        spotlightGradient.addColorStop(1, `${palette.highlight}00`);
+        context.fillStyle = spotlightGradient;
+        context.fillRect(0, 0, size, size);
+        const rimGradient = context.createLinearGradient(0, size * 0.14, 0, size * 0.92);
+        rimGradient.addColorStop(0, `${palette.highlight}12`);
+        rimGradient.addColorStop(0.55, `${palette.secondary}0a`);
+        rimGradient.addColorStop(1, `${palette.shadow}00`);
+        context.fillStyle = rimGradient;
+        context.fillRect(0, 0, size, size);
+        context.save();
+        context.globalAlpha = 0.08 + interaction.intensity * 0.04;
+        context.fillStyle = palette.highlight;
+        context.beginPath();
+        context.arc(size * 0.72 + Math.sin(timeMs / 1600) * size * 0.03, size * 0.2 + Math.cos(timeMs / 1400) * size * 0.018, size * 0.025, 0, Math.PI * 2);
+        context.fill();
+        context.restore();
+    }
+    /**
+     * Draws the soft floor shadow used to anchor the cuboids in the frame.
+     *
+     * @param context Canvas 2D context.
+     * @param size Canvas size in CSS pixels.
+     * @param palette Derived avatar palette.
+     * @param interaction Smoothed pointer-aware interaction state.
+     * @param timeMs Current animation time in milliseconds.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function drawMinecraftShadow(context, size, palette, interaction, timeMs) {
+        context.save();
+        context.fillStyle = `${palette.shadow}66`;
+        context.filter = `blur(${size * 0.02}px)`;
+        context.beginPath();
+        context.ellipse(size * 0.5 + interaction.gazeX * size * 0.03, size * 0.85 + Math.sin(timeMs / 880) * size * 0.01, size * (0.16 + interaction.intensity * 0.015), size * 0.055, 0, 0, Math.PI * 2);
+        context.fill();
+        context.restore();
+    }
+    /**
+     * Resolves all visible projected faces for one scene cuboid.
+     *
+     * @param cuboid Scene cuboid definition.
+     * @param size Canvas size in CSS pixels.
+     * @param sceneCenterX Horizontal scene center.
+     * @param sceneCenterY Vertical scene center.
+     * @returns Visible faces sorted later by depth.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function resolveVisibleCuboidFaces(cuboid, size, sceneCenterX, sceneCenterY) {
+        const halfWidth = cuboid.width / 2;
+        const halfHeight = cuboid.height / 2;
+        const halfDepth = cuboid.depth / 2;
+        const faceDefinitions = [
+            {
+                texture: cuboid.textures.front,
+                corners: [
+                    { x: -halfWidth, y: -halfHeight, z: halfDepth },
+                    { x: halfWidth, y: -halfHeight, z: halfDepth },
+                    { x: halfWidth, y: halfHeight, z: halfDepth },
+                    { x: -halfWidth, y: halfHeight, z: halfDepth },
+                ],
+            },
+            {
+                texture: cuboid.textures.back,
+                corners: [
+                    { x: halfWidth, y: -halfHeight, z: -halfDepth },
+                    { x: -halfWidth, y: -halfHeight, z: -halfDepth },
+                    { x: -halfWidth, y: halfHeight, z: -halfDepth },
+                    { x: halfWidth, y: halfHeight, z: -halfDepth },
+                ],
+            },
+            {
+                texture: cuboid.textures.right,
+                corners: [
+                    { x: halfWidth, y: -halfHeight, z: halfDepth },
+                    { x: halfWidth, y: -halfHeight, z: -halfDepth },
+                    { x: halfWidth, y: halfHeight, z: -halfDepth },
+                    { x: halfWidth, y: halfHeight, z: halfDepth },
+                ],
+            },
+            {
+                texture: cuboid.textures.left,
+                corners: [
+                    { x: -halfWidth, y: -halfHeight, z: -halfDepth },
+                    { x: -halfWidth, y: -halfHeight, z: halfDepth },
+                    { x: -halfWidth, y: halfHeight, z: halfDepth },
+                    { x: -halfWidth, y: halfHeight, z: -halfDepth },
+                ],
+            },
+            {
+                texture: cuboid.textures.top,
+                corners: [
+                    { x: -halfWidth, y: -halfHeight, z: -halfDepth },
+                    { x: halfWidth, y: -halfHeight, z: -halfDepth },
+                    { x: halfWidth, y: -halfHeight, z: halfDepth },
+                    { x: -halfWidth, y: -halfHeight, z: halfDepth },
+                ],
+            },
+            {
+                texture: cuboid.textures.bottom,
+                corners: [
+                    { x: -halfWidth, y: halfHeight, z: halfDepth },
+                    { x: halfWidth, y: halfHeight, z: halfDepth },
+                    { x: halfWidth, y: halfHeight, z: -halfDepth },
+                    { x: -halfWidth, y: halfHeight, z: -halfDepth },
+                ],
+            },
+        ];
+        const visibleFaces = faceDefinitions
+            .map((faceDefinition) => {
+            const transformedCorners = faceDefinition.corners.map((corner) => transformScenePoint(corner, cuboid.center, cuboid.rotationX, cuboid.rotationY));
+            const faceNormal = normalizeVector3(crossProduct3D(subtractPoint3D(transformedCorners[1], transformedCorners[0]), subtractPoint3D(transformedCorners[2], transformedCorners[0])));
+            if (faceNormal.z <= 0.02) {
+                return null;
             }
+            const projectedCorners = transformedCorners.map((corner) => projectScenePoint(corner, size, sceneCenterX, sceneCenterY));
+            return {
+                corners: projectedCorners,
+                texture: faceDefinition.texture,
+                averageDepth: transformedCorners.reduce((depthSum, corner) => depthSum + corner.z, 0) / transformedCorners.length,
+                lightIntensity: clampNumber$1(dotProduct3D(faceNormal, LIGHT_DIRECTION), -1, 1),
+                outlineColor: cuboid.outlineColor,
+            };
+        });
+        return visibleFaces.filter((visibleFace) => visibleFace !== null);
+    }
+    /**
+     * Draws one projected textured face by tessellating its texture cells into quads.
+     *
+     * @param context Canvas 2D context.
+     * @param face Visible projected face.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function drawTexturedProjectedFace(context, face) {
+        var _a;
+        const rows = face.texture.length;
+        const columns = ((_a = face.texture[0]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        if (rows === 0 || columns === 0) {
+            return;
         }
-        texture[2][0] = hairlineColor;
-        texture[2][7] = hairlineColor;
-        texture[3][0] = hairlineColor;
-        texture[3][7] = hairlineColor;
-        if (hasHeadband) {
-            for (let columnIndex = 0; columnIndex < 8; columnIndex++) {
-                texture[2][columnIndex] = palette.accent;
+        for (let rowIndex = 0; rowIndex < rows; rowIndex++) {
+            for (let columnIndex = 0; columnIndex < columns; columnIndex++) {
+                const startX = columnIndex / columns;
+                const endX = (columnIndex + 1) / columns;
+                const startY = rowIndex / rows;
+                const endY = (rowIndex + 1) / rows;
+                drawProjectedQuad(context, [
+                    interpolateProjectedQuad(face.corners, startX, startY),
+                    interpolateProjectedQuad(face.corners, endX, startY),
+                    interpolateProjectedQuad(face.corners, endX, endY),
+                    interpolateProjectedQuad(face.corners, startX, endY),
+                ], face.texture[rowIndex][columnIndex]);
             }
         }
-        texture[3][2] = palette.ink;
-        texture[3][5] = palette.ink;
-        texture[4][2] = '#ffffff';
-        texture[4][5] = '#ffffff';
-        texture[5][1] = cheekColor;
-        texture[5][6] = cheekColor;
-        texture[5][3] = palette.shadow;
-        texture[5][4] = palette.shadow;
-        texture[6][3] = palette.shadow;
-        texture[6][4] = palette.shadow;
-        return texture;
+        if (face.lightIntensity > 0) {
+            drawProjectedQuad(context, face.corners, `rgba(255, 255, 255, ${0.15 * face.lightIntensity})`);
+        }
+        else if (face.lightIntensity < 0) {
+            drawProjectedQuad(context, face.corners, `rgba(0, 0, 0, ${0.22 * Math.abs(face.lightIntensity)})`);
+        }
+        context.save();
+        context.beginPath();
+        context.moveTo(face.corners[0].x, face.corners[0].y);
+        for (let cornerIndex = 1; cornerIndex < face.corners.length; cornerIndex++) {
+            context.lineTo(face.corners[cornerIndex].x, face.corners[cornerIndex].y);
+        }
+        context.closePath();
+        context.strokeStyle = face.outlineColor;
+        context.lineWidth = Math.max(1.1, getProjectedQuadPerimeter(face.corners) * 0.0045);
+        context.lineJoin = 'round';
+        context.stroke();
+        context.restore();
     }
     /**
-     * Creates the front-face pixel texture for the torso.
+     * Draws one filled projected quad.
      *
-     * @param random Seeded random generator.
-     * @param palette Derived avatar palette.
-     * @returns 8x8 torso texture.
+     * @param context Canvas 2D context.
+     * @param corners Quad corners in clockwise order.
+     * @param fillStyle CSS fill style.
      *
-     * @private helper of `minecraftAvatarVisual`
+     * @private helper of `minecraft2AvatarVisual`
      */
-    function createMinecraftShirtTexture(random, palette) {
-        const texture = Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => palette.primary));
-        const stripeColor = random() < 0.5 ? palette.secondary : palette.highlight;
-        for (let rowIndex = 0; rowIndex < 2; rowIndex++) {
-            for (let columnIndex = 0; columnIndex < 8; columnIndex++) {
-                texture[rowIndex][columnIndex] = palette.shadow;
-            }
+    function drawProjectedQuad(context, corners, fillStyle) {
+        context.beginPath();
+        context.moveTo(corners[0].x, corners[0].y);
+        context.lineTo(corners[1].x, corners[1].y);
+        context.lineTo(corners[2].x, corners[2].y);
+        context.lineTo(corners[3].x, corners[3].y);
+        context.closePath();
+        context.fillStyle = fillStyle;
+        context.fill();
+    }
+    /**
+     * Interpolates one point inside a projected quad across both quad axes.
+     *
+     * @param corners Quad corners in clockwise order.
+     * @param horizontalRatio Horizontal ratio in the range `[0, 1]`.
+     * @param verticalRatio Vertical ratio in the range `[0, 1]`.
+     * @returns Interpolated projected point.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function interpolateProjectedQuad(corners, horizontalRatio, verticalRatio) {
+        const topPoint = interpolateProjectedPoint(corners[0], corners[1], horizontalRatio);
+        const bottomPoint = interpolateProjectedPoint(corners[3], corners[2], horizontalRatio);
+        return interpolateProjectedPoint(topPoint, bottomPoint, verticalRatio);
+    }
+    /**
+     * Interpolates between two projected points.
+     *
+     * @param startPoint Start point.
+     * @param endPoint End point.
+     * @param ratio Interpolation ratio in the range `[0, 1]`.
+     * @returns Interpolated projected point.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function interpolateProjectedPoint(startPoint, endPoint, ratio) {
+        return {
+            x: startPoint.x + (endPoint.x - startPoint.x) * ratio,
+            y: startPoint.y + (endPoint.y - startPoint.y) * ratio,
+            z: startPoint.z + (endPoint.z - startPoint.z) * ratio,
+        };
+    }
+    /**
+     * Projects one rotated scene point into canvas coordinates.
+     *
+     * @param point Scene point.
+     * @param size Canvas size in CSS pixels.
+     * @param sceneCenterX Horizontal scene center.
+     * @param sceneCenterY Vertical scene center.
+     * @returns Projected point.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function projectScenePoint(point, size, sceneCenterX, sceneCenterY) {
+        const cameraDistance = size * CAMERA_DISTANCE_RATIO;
+        const perspectiveScale = cameraDistance / Math.max(cameraDistance - point.z, cameraDistance * 0.35);
+        return {
+            x: sceneCenterX + point.x * perspectiveScale,
+            y: sceneCenterY + point.y * perspectiveScale,
+            z: point.z,
+        };
+    }
+    /**
+     * Applies the local cuboid rotations and translation to one scene point.
+     *
+     * @param localPoint Point in cuboid-local space.
+     * @param center Cuboid center in scene space.
+     * @param rotationX Cuboid pitch in radians.
+     * @param rotationY Cuboid yaw in radians.
+     * @returns Transformed scene-space point.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function transformScenePoint(localPoint, center, rotationX, rotationY) {
+        const yawedPoint = rotatePointAroundY(localPoint, rotationY);
+        const pitchedPoint = rotatePointAroundX(yawedPoint, rotationX);
+        return {
+            x: center.x + pitchedPoint.x,
+            y: center.y + pitchedPoint.y,
+            z: center.z + pitchedPoint.z,
+        };
+    }
+    /**
+     * Rotates one point around the local Y axis.
+     *
+     * @param point Source point.
+     * @param angle Rotation angle in radians.
+     * @returns Rotated point.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function rotatePointAroundY(point, angle) {
+        const cosine = Math.cos(angle);
+        const sine = Math.sin(angle);
+        return {
+            x: point.x * cosine + point.z * sine,
+            y: point.y,
+            z: -point.x * sine + point.z * cosine,
+        };
+    }
+    /**
+     * Rotates one point around the local X axis.
+     *
+     * @param point Source point.
+     * @param angle Rotation angle in radians.
+     * @returns Rotated point.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function rotatePointAroundX(point, angle) {
+        const cosine = Math.cos(angle);
+        const sine = Math.sin(angle);
+        return {
+            x: point.x,
+            y: point.y * cosine - point.z * sine,
+            z: point.y * sine + point.z * cosine,
+        };
+    }
+    /**
+     * Subtracts one 3D point from another.
+     *
+     * @param leftPoint Left point.
+     * @param rightPoint Right point.
+     * @returns Difference vector.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function subtractPoint3D(leftPoint, rightPoint) {
+        return {
+            x: leftPoint.x - rightPoint.x,
+            y: leftPoint.y - rightPoint.y,
+            z: leftPoint.z - rightPoint.z,
+        };
+    }
+    /**
+     * Computes the 3D cross product of two vectors.
+     *
+     * @param leftVector Left vector.
+     * @param rightVector Right vector.
+     * @returns Cross product.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function crossProduct3D(leftVector, rightVector) {
+        return {
+            x: leftVector.y * rightVector.z - leftVector.z * rightVector.y,
+            y: leftVector.z * rightVector.x - leftVector.x * rightVector.z,
+            z: leftVector.x * rightVector.y - leftVector.y * rightVector.x,
+        };
+    }
+    /**
+     * Computes the 3D dot product of two vectors.
+     *
+     * @param leftVector Left vector.
+     * @param rightVector Right vector.
+     * @returns Dot product.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function dotProduct3D(leftVector, rightVector) {
+        return leftVector.x * rightVector.x + leftVector.y * rightVector.y + leftVector.z * rightVector.z;
+    }
+    /**
+     * Normalizes one 3D vector while keeping zero vectors stable.
+     *
+     * @param vector Source vector.
+     * @returns Normalized vector.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function normalizeVector3(vector) {
+        const length = Math.hypot(vector.x, vector.y, vector.z);
+        if (length === 0) {
+            return vector;
         }
-        for (let rowIndex = 2; rowIndex < 8; rowIndex++) {
-            texture[rowIndex][3] = stripeColor;
-            texture[rowIndex][4] = stripeColor;
+        return {
+            x: vector.x / length,
+            y: vector.y / length,
+            z: vector.z / length,
+        };
+    }
+    /**
+     * Clamps one number into the provided range.
+     *
+     * @param value Input value.
+     * @param minimumValue Inclusive lower bound.
+     * @param maximumValue Inclusive upper bound.
+     * @returns Clamped value.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function clampNumber$1(value, minimumValue, maximumValue) {
+        return Math.min(maximumValue, Math.max(minimumValue, value));
+    }
+    /**
+     * Measures the perimeter of one projected quad.
+     *
+     * @param corners Quad corners.
+     * @returns Perimeter length.
+     *
+     * @private helper of `minecraft2AvatarVisual`
+     */
+    function getProjectedQuadPerimeter(corners) {
+        let perimeter = 0;
+        for (let cornerIndex = 0; cornerIndex < corners.length; cornerIndex++) {
+            const currentCorner = corners[cornerIndex];
+            const nextCorner = corners[(cornerIndex + 1) % corners.length];
+            perimeter += Math.hypot(nextCorner.x - currentCorner.x, nextCorner.y - currentCorner.y);
         }
-        texture[4][1] = palette.accent;
-        texture[4][6] = palette.accent;
-        texture[5][2] = palette.highlight;
-        texture[5][5] = palette.highlight;
-        return texture;
+        return perimeter;
     }
 
     /* eslint-disable no-magic-numbers */
@@ -24482,6 +25119,7 @@
         octopus3AvatarVisual,
         asciiOctopusAvatarVisual,
         minecraftAvatarVisual,
+        minecraft2AvatarVisual,
         fractalAvatarVisual,
         orbAvatarVisual,
     ];
@@ -26690,7 +27328,10 @@
      */
     function buildTeamToolDescription(entry) {
         const detailLines = collectTeamEntryDetails(entry).map(({ label, content }) => `${label}: ${content}`);
-        return [`Consult teammate ${entry.teammate.label}`, ...detailLines].join('\n');
+        return _spaceTrim.spaceTrim((block) => `
+            Consult teammate ${entry.teammate.label}
+            ${block(detailLines.join('\n'))}
+        `);
     }
     /**
      * Collects structured teammate details that should stay visible to the model.
@@ -32187,7 +32828,10 @@
         if (hiddenCount > 0) {
             summaryRows.push(`...and ${hiddenCount} more.`);
         }
-        return [`Found ${options.total} ${options.total === 1 ? 'timeout' : 'timeouts'}:`, ...summaryRows].join('\n');
+        return _spaceTrim.spaceTrim((block) => `
+            Found ${options.total} ${options.total === 1 ? 'timeout' : 'timeouts'}:
+            ${block(summaryRows.join('\n'))}
+        `);
     }
     /**
      * Formats one timeout row for assistant-visible timeout listings.
@@ -37178,8 +37822,10 @@
             **Application mode:** ${serverInfo.isApplicationModeAllowed ? 'enabled' : 'disabled'}
             ${block(!runtime.configuration.isApplicationModeAllowed || runtime.configuration.collection === null
         ? ''
-        : '**Pipelines in collection:**\n' +
-            serverInfo.pipelines.map((pipelineUrl) => `- ${pipelineUrl}`).join('\n'))}
+        : _spaceTrim.spaceTrim((nestedBlock) => `
+                              **Pipelines in collection:**
+                              ${nestedBlock(serverInfo.pipelines.map((pipelineUrl) => `- ${pipelineUrl}`).join('\n'))}
+                          `))}
             **Running executions:** ${serverInfo.runningExecutions}
 
             ---
@@ -50908,7 +51554,7 @@
      */
     async function commitChanges(message, options) {
         const projectPath = process.cwd();
-        const commitMessagePath = path.join(projectPath, '.tmp', 'codex-prompts', `COMMIT_MESSAGE_${Date.now()}.txt`);
+        const commitMessagePath = resolvePromptbookTempPath(projectPath, 'scripts', 'codex-prompts', `COMMIT_MESSAGE_${Date.now()}.txt`);
         await promises.mkdir(path.dirname(commitMessagePath), { recursive: true });
         await promises.writeFile(commitMessagePath, message, 'utf-8');
         try {
@@ -51876,17 +52522,18 @@
 
             unset GITHUB_TOKEN
 
-            copilot -p "$(cat <<'${delimiter}'
-
-            ${block(options.prompt)}
-
-            ${delimiter}
-            )" \\
+            # Avoid passing the prompt as one CLI argument because large agent prompts can exceed Windows/MSYS limits.
+            copilot \\
                 --yolo \\
                 --no-ask-user \\
                 --no-color \\
                 --output-format json \\
-                --stream off${modelArgument}${thinkingLevelArgument}
+                --stream off${modelArgument}${thinkingLevelArgument} \\
+                <<'${delimiter}'
+
+            ${block(options.prompt)}
+
+            ${delimiter}
         `);
     }
 
@@ -53165,148 +53812,14 @@
             .map((line) => centerAnsiText(line, options.totalWidth));
     }
 
-    /**
-     * Refresh cadence used only while the rich coder UI needs animated updates.
-     *
-     * @private internal constant of coder run UI
-     */
-    const ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS = 300;
-    /**
-     * Phases that still benefit from automatic refreshes because the frame can change
-     * over time even without new runner output.
-     *
-     * @private internal constant of coder run UI
-     */
-    const AUTO_REFRESH_PHASES = ['initializing', 'loading', 'running', 'verifying'];
-    /**
-     * Returns whether the rich coder UI should keep animating on its own.
-     *
-     * @private internal utility of coder run UI
-     */
-    function isCoderRunUiAutoRefreshing(phase, pauseState) {
-        // `PAUSING` still means the current task is winding down, so keep active
-        // animations/timers running until the runner reaches the fully paused state.
-        if (pauseState === 'PAUSED') {
-            return false;
-        }
-        return AUTO_REFRESH_PHASES.includes(phase);
-    }
-    /**
-     * Returns the automatic refresh interval for the current UI state.
-     *
-     * Waiting, paused, and completed states return `undefined` so the rich UI stays
-     * perfectly still until actual state changes arrive.
-     *
-     * @private internal utility of coder run UI
-     */
-    function getCoderRunUiAutoRefreshInterval(phase, pauseState) {
-        return isCoderRunUiAutoRefreshing(phase, pauseState) ? ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS : undefined;
-    }
-
     /**
      * Maximum number of output lines reserved for agent output in the UI.
      */
     const MAX_VISIBLE_OUTPUT_LINES = 8;
-    /**
-     * Minimum width used for the rich coder-run frame.
-     */
-    const MIN_FRAME_WIDTH = 56;
-    /**
-     * Maximum width used for the rich coder-run frame.
-     */
-    const MAX_FRAME_WIDTH = 96;
     /**
      * Visible width reserved for aligned labels in the session box.
      */
     const SESSION_LABEL_WIDTH = 8;
-    /**
-     * Builds the complete boxed terminal frame for the rich `ptbk coder run` UI.
-     */
-    function buildCoderRunUiFrame(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__default["default"].yellow(`${options.spinner} `)}` : '';
-        const octopusAnimationFrame = isCoderRunUiAutoRefreshing(options.phase, options.pauseState)
-            ? options.animationFrame
-            : 0;
-        const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.statusMessage);
-        const sessionLines = buildSessionLines(options, totalWidth, pausePresentation);
-        const currentTaskLines = options.currentPromptLabel
-            ? [
-                `${promptStatusPrefix}${colors__default["default"].bold.white(fitPlainText(options.currentPromptLabel, totalWidth - 8))}`,
-                `Attempt ${options.currentAttempt}/${options.maxAttempts}  ·  ${options.statusMessage}`,
-                ...options.detailLines.map((detailLine) => `• ${detailLine}`),
-            ]
-            : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
-        const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
-        const controls = buildControlPills(pausePresentation.pauseControl, options.pendingEnterLabel).join('  ');
-        const frame = [
-            ...buildCoderRunOctopusVisual({ totalWidth, animationFrame: octopusAnimationFrame }),
-            '',
-            ...renderBox('Session', sessionLines, totalWidth, colors__default["default"].yellow.bold),
-            ...renderBox(options.currentPromptLabel ? 'Current task' : 'Queue', currentTaskLines, totalWidth, colors__default["default"].magenta.bold),
-            ...renderBox('Live output', visibleOutputLines, totalWidth, colors__default["default"].green.bold),
-        ];
-        if (options.errors.length > 0) {
-            frame.push(...renderBox('Errors', options.errors.map((errorLine) => `${colors__default["default"].red('✗')} ${errorLine}`), totalWidth, colors__default["default"].red.bold));
-        }
-        frame.push(...renderBox('Controls', [controls], totalWidth, colors__default["default"].white.bold));
-        return frame;
-    }
-    /**
-     * Builds the structured session lines that combine state, runner, queue, and timing metadata.
-     */
-    function buildSessionLines(options, totalWidth, pausePresentation) {
-        const bodyWidth = Math.max(10, totalWidth - 4);
-        return buildSessionRows(options, bodyWidth, pausePresentation).map((sessionRow) => buildLabeledSessionLine(sessionRow.label, sessionRow.value, bodyWidth));
-    }
-    /**
-     * Builds the session rows so the renderer can keep one consistent structure without duplicating labels.
-     */
-    function buildSessionRows(options, bodyWidth, pausePresentation) {
-        const runnerParts = [options.config.agentName || 'No agent selected'];
-        if (options.config.modelName) {
-            runnerParts.push(options.config.modelName);
-        }
-        if (options.config.thinkingLevel) {
-            runnerParts.push(`thinking ${options.config.thinkingLevel}`);
-        }
-        const configurationRows = [
-            ...buildOptionalSessionRow('Context', options.config.context),
-            ...buildOptionalSessionRow('Test', options.config.testCommand),
-        ];
-        return [
-            {
-                label: 'State',
-                value: `${pausePresentation.badge} ${pausePresentation.stateMessage}`,
-            },
-            {
-                label: 'Runner',
-                value: runnerParts.join('  ·  '),
-            },
-            ...configurationRows,
-            {
-                label: 'This run',
-                value: buildThisRunSummary(options.progress),
-            },
-            {
-                label: 'Backlog',
-                value: buildBacklogSummary(options.progress),
-            },
-            {
-                label: 'Scope',
-                value: buildScopeSummary(options.progress, options.config),
-            },
-            {
-                label: 'Timing',
-                value: buildTimingSummary(options.progress),
-            },
-            {
-                label: 'Progress',
-                value: buildProgressBar$1(options.progress.percentage, bodyWidth - SESSION_LABEL_WIDTH - 1, `${options.progress.percentage}% complete (${options.progress.sessionDone}/${options.progress.sessionTotal} done)`),
-            },
-        ];
-    }
     /**
      * Builds the fixed-height live output section so streaming updates do not keep resizing the frame.
      */
@@ -53342,50 +53855,6 @@
         const formattedLabel = colors__default["default"].gray(label.padEnd(SESSION_LABEL_WIDTH));
         return `${formattedLabel} ${fitAnsiText(value, bodyWidth - SESSION_LABEL_WIDTH - 1)}`;
     }
-    /**
-     * Builds zero or one structured session row for optional metadata.
-     */
-    function buildOptionalSessionRow(label, value) {
-        if (!value) {
-            return [];
-        }
-        return [{ label, value }];
-    }
-    /**
-     * Builds the active-session summary shown in the session box.
-     */
-    function buildThisRunSummary(progress) {
-        if (progress.sessionTotal === 0) {
-            return 'No runnable prompts in current scope';
-        }
-        return `Task ${progress.currentPromptIndex}/${progress.sessionTotal}  ·  ${progress.sessionDone} done  ·  ${progress.sessionRemaining} left`;
-    }
-    /**
-     * Builds the backlog/filter summary shown in the session box.
-     */
-    function buildBacklogSummary(progress) {
-        const parts = [`Repo ${progress.totalPrompts} total`];
-        if (progress.skippedPrompts > 0) {
-            parts.push(`${formatPromptCount$1(progress.skippedPrompts)} below priority`);
-        }
-        return parts.join('  ·  ');
-    }
-    /**
-     * Builds the priority/write-order summary shown in the session box.
-     */
-    function buildScopeSummary(progress, config) {
-        const parts = [`Priority ≥${config.priority}`];
-        if (progress.toBeWrittenPrompts > 0) {
-            parts.push(`Write ${formatPromptCount$1(progress.toBeWrittenPrompts)} first`);
-        }
-        return parts.join('  ·  ');
-    }
-    /**
-     * Builds the elapsed/estimate summary shown in the session box.
-     */
-    function buildTimingSummary(progress) {
-        return `Elapsed ${progress.elapsedText}  ·  Total ${progress.estimatedTotalText}  ·  ETA ${progress.estimatedLabel}`;
-    }
     /**
      * Builds the colored phase badge shown in the session box.
      */
@@ -53410,6 +53879,28 @@
             pauseControl: colors__default["default"].bgYellow.black(' P ') + colors__default["default"].white(' Pause'),
         };
     }
+    /**
+     * Builds the progress bar shown in the session box.
+     */
+    function buildProgressBar$1(percentage, availableWidth, label) {
+        const percentageLabel = label;
+        const barWidth = Math.max(10, availableWidth - percentageLabel.length - 1);
+        const filledWidth = Math.round((percentage / 100) * barWidth);
+        const emptyWidth = Math.max(0, barWidth - filledWidth);
+        return `${colors__default["default"].green('█'.repeat(filledWidth))}${colors__default["default"].blue('░'.repeat(emptyWidth))} ${percentageLabel}`;
+    }
+    /**
+     * Builds the control pills shown in the footer box.
+     */
+    function buildControlPills(pauseControl, pendingEnterLabel) {
+        const pills = [];
+        if (pendingEnterLabel) {
+            pills.push(colors__default["default"].bgWhite.black(' ENTER ') + colors__default["default"].white(` ${pendingEnterLabel}`));
+        }
+        pills.push(pauseControl);
+        pills.push(colors__default["default"].bgRed.white(' CTRL+C ') + colors__default["default"].white(' Exit'));
+        return pills;
+    }
     /**
      * Builds the active phase badge shown in the session box while the runner is not paused.
      */
@@ -53434,33 +53925,190 @@
                 return colors__default["default"].bgWhite.black(' READY ');
         }
     }
+
     /**
-     * Builds the progress bar shown in the session box.
+     * Refresh cadence used only while the rich coder UI needs animated updates.
+     *
+     * @private internal constant of coder run UI
      */
-    function buildProgressBar$1(percentage, availableWidth, label) {
-        const percentageLabel = label;
-        const barWidth = Math.max(10, availableWidth - percentageLabel.length - 1);
-        const filledWidth = Math.round((percentage / 100) * barWidth);
-        const emptyWidth = Math.max(0, barWidth - filledWidth);
-        return `${colors__default["default"].green('█'.repeat(filledWidth))}${colors__default["default"].blue('░'.repeat(emptyWidth))} ${percentageLabel}`;
+    const ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS = 300;
+    /**
+     * Phases that still benefit from automatic refreshes because the frame can change
+     * over time even without new runner output.
+     *
+     * @private internal constant of coder run UI
+     */
+    const AUTO_REFRESH_PHASES = ['initializing', 'loading', 'running', 'verifying'];
+    /**
+     * Returns whether the rich coder UI should keep animating on its own.
+     *
+     * @private internal utility of coder run UI
+     */
+    function isCoderRunUiAutoRefreshing(phase, pauseState) {
+        // `PAUSING` still means the current task is winding down, so keep active
+        // animations/timers running until the runner reaches the fully paused state.
+        if (pauseState === 'PAUSED') {
+            return false;
+        }
+        return AUTO_REFRESH_PHASES.includes(phase);
     }
     /**
-     * Formats a prompt count with singular/plural wording.
+     * Returns the automatic refresh interval for the current UI state.
+     *
+     * Waiting, paused, and completed states return `undefined` so the rich UI stays
+     * perfectly still until actual state changes arrive.
+     *
+     * @private internal utility of coder run UI
      */
-    function formatPromptCount$1(count) {
-        return `${count} prompt${count === 1 ? '' : 's'}`;
+    function getCoderRunUiAutoRefreshInterval(phase, pauseState) {
+        return isCoderRunUiAutoRefreshing(phase, pauseState) ? ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS : undefined;
     }
+
     /**
-     * Builds the control pills shown in the footer box.
+     * Minimum width used for the rich coder-run frame.
      */
-    function buildControlPills(pauseControl, pendingEnterLabel) {
-        const pills = [];
-        if (pendingEnterLabel) {
-            pills.push(colors__default["default"].bgWhite.black(' ENTER ') + colors__default["default"].white(` ${pendingEnterLabel}`));
+    const MIN_FRAME_WIDTH$1 = 56;
+    /**
+     * Maximum width used for the rich coder-run frame.
+     */
+    const MAX_FRAME_WIDTH$1 = 96;
+    /**
+     * Builds the complete boxed terminal frame for the rich `ptbk coder run` UI.
+     */
+    function buildCoderRunUiFrame(options) {
+        const totalWidth = Math.max(MIN_FRAME_WIDTH$1, Math.min(options.terminalWidth, MAX_FRAME_WIDTH$1));
+        const isPromptActive = options.phase === 'running' || options.phase === 'verifying' || options.phase === 'loading';
+        const promptStatusPrefix = isPromptActive ? `${colors__default["default"].yellow(`${options.spinner} `)}` : '';
+        const octopusAnimationFrame = isCoderRunUiAutoRefreshing(options.phase, options.pauseState)
+            ? options.animationFrame
+            : 0;
+        const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.statusMessage);
+        const sessionLines = buildSessionLines$1(options, totalWidth, pausePresentation);
+        const currentTaskLines = options.currentPromptLabel
+            ? [
+                `${promptStatusPrefix}${colors__default["default"].bold.white(fitPlainText(options.currentPromptLabel, totalWidth - 8))}`,
+                `Attempt ${options.currentAttempt}/${options.maxAttempts}  ·  ${options.statusMessage}`,
+                ...options.detailLines.map((detailLine) => `• ${detailLine}`),
+            ]
+            : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
+        const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
+        const controls = buildControlPills(pausePresentation.pauseControl, options.pendingEnterLabel).join('  ');
+        const frame = [
+            ...buildCoderRunOctopusVisual({ totalWidth, animationFrame: octopusAnimationFrame }),
+            '',
+            ...renderBox('Session', sessionLines, totalWidth, colors__default["default"].yellow.bold),
+            ...renderBox(options.currentPromptLabel ? 'Current task' : 'Queue', currentTaskLines, totalWidth, colors__default["default"].magenta.bold),
+            ...renderBox('Live output', visibleOutputLines, totalWidth, colors__default["default"].green.bold),
+        ];
+        if (options.errors.length > 0) {
+            frame.push(...renderBox('Errors', options.errors.map((errorLine) => `${colors__default["default"].red('✗')} ${errorLine}`), totalWidth, colors__default["default"].red.bold));
         }
-        pills.push(pauseControl);
-        pills.push(colors__default["default"].bgRed.white(' CTRL+C ') + colors__default["default"].white(' Exit'));
-        return pills;
+        frame.push(...renderBox('Controls', [controls], totalWidth, colors__default["default"].white.bold));
+        return frame;
+    }
+    /**
+     * Builds the structured session lines that combine state, runner, queue, and timing metadata.
+     */
+    function buildSessionLines$1(options, totalWidth, pausePresentation) {
+        const bodyWidth = Math.max(10, totalWidth - 4);
+        return buildSessionRows(options, bodyWidth, pausePresentation).map((sessionRow) => buildLabeledSessionLine(sessionRow.label, sessionRow.value, bodyWidth));
+    }
+    /**
+     * Builds the session rows so the renderer can keep one consistent structure without duplicating labels.
+     */
+    function buildSessionRows(options, bodyWidth, pausePresentation) {
+        const runnerParts = [options.config.agentName || 'No agent selected'];
+        if (options.config.modelName) {
+            runnerParts.push(options.config.modelName);
+        }
+        if (options.config.thinkingLevel) {
+            runnerParts.push(`thinking ${options.config.thinkingLevel}`);
+        }
+        const configurationRows = [
+            ...buildOptionalSessionRow('Context', options.config.context),
+            ...buildOptionalSessionRow('Test', options.config.testCommand),
+        ];
+        return [
+            {
+                label: 'State',
+                value: `${pausePresentation.badge} ${pausePresentation.stateMessage}`,
+            },
+            {
+                label: 'Runner',
+                value: runnerParts.join('  ·  '),
+            },
+            ...configurationRows,
+            {
+                label: 'This run',
+                value: buildThisRunSummary(options.progress),
+            },
+            {
+                label: 'Backlog',
+                value: buildBacklogSummary(options.progress),
+            },
+            {
+                label: 'Scope',
+                value: buildScopeSummary(options.progress, options.config),
+            },
+            {
+                label: 'Timing',
+                value: buildTimingSummary(options.progress),
+            },
+            {
+                label: 'Progress',
+                value: buildProgressBar$1(options.progress.percentage, bodyWidth - SESSION_LABEL_WIDTH - 1, `${options.progress.percentage}% complete (${options.progress.sessionDone}/${options.progress.sessionTotal} done)`),
+            },
+        ];
+    }
+    /**
+     * Builds zero or one structured session row for optional metadata.
+     */
+    function buildOptionalSessionRow(label, value) {
+        if (!value) {
+            return [];
+        }
+        return [{ label, value }];
+    }
+    /**
+     * Builds the active-session summary shown in the session box.
+     */
+    function buildThisRunSummary(progress) {
+        if (progress.sessionTotal === 0) {
+            return 'No runnable prompts in current scope';
+        }
+        return `Task ${progress.currentPromptIndex}/${progress.sessionTotal}  ·  ${progress.sessionDone} done  ·  ${progress.sessionRemaining} left`;
+    }
+    /**
+     * Builds the backlog/filter summary shown in the session box.
+     */
+    function buildBacklogSummary(progress) {
+        const parts = [`Repo ${progress.totalPrompts} total`];
+        if (progress.skippedPrompts > 0) {
+            parts.push(`${formatPromptCount$1(progress.skippedPrompts)} below priority`);
+        }
+        return parts.join('  ·  ');
+    }
+    /**
+     * Builds the priority/write-order summary shown in the session box.
+     */
+    function buildScopeSummary(progress, config) {
+        const parts = [`Priority ≥${config.priority}`];
+        if (progress.toBeWrittenPrompts > 0) {
+            parts.push(`Write ${formatPromptCount$1(progress.toBeWrittenPrompts)} first`);
+        }
+        return parts.join('  ·  ');
+    }
+    /**
+     * Builds the elapsed/estimate summary shown in the session box.
+     */
+    function buildTimingSummary(progress) {
+        return `Elapsed ${progress.elapsedText}  ·  Total ${progress.estimatedTotalText}  ·  ETA ${progress.estimatedLabel}`;
+    }
+    /**
+     * Formats a prompt count with singular/plural wording.
+     */
+    function formatPromptCount$1(count) {
+        return `${count} prompt${count === 1 ? '' : 's'}`;
     }
 
     /**
@@ -53603,6 +54251,7 @@
             this.currentAttempt = 1;
             this.maxAttempts = 3;
             this.detailLines = [];
+            this.messagePreviewLines = [];
             this.agentOutputLines = [];
             this.phase = 'initializing';
             this.statusMessage = 'Initializing...';
@@ -53656,6 +54305,7 @@
         setCurrentPrompt(label) {
             this.currentPromptLabel = label;
             this.detailLines = [];
+            this.messagePreviewLines = [];
             this.pendingEnterLabel = undefined;
             this.agentOutputLines = [];
             this.currentAttempt = 1;
@@ -53703,6 +54353,13 @@
             this.detailLines = detailLines.filter((detailLine) => detailLine.trim() !== '');
             this.emitChange();
         }
+        /**
+         * Replaces the exact user-message preview lines shown in agent-specific panels.
+         */
+        setMessagePreviewLines(messagePreviewLines) {
+            this.messagePreviewLines = [...messagePreviewLines];
+            this.emitChange();
+        }
         /**
          * Sets or clears the Enter-key action label shown in the controls panel.
          */
@@ -53760,8 +54417,9 @@
      *
      * @private internal entry point of coder run UI
      */
-    function renderCoderRunUi(startTime) {
+    function renderCoderRunUi(startTime, options = {}) {
         const state = new CoderRunUiState(startTime);
+        const buildFrameLinesFromState = options.buildFrameLines || buildCoderRunUiFrame;
         if (!process.stdout.isTTY) {
             return {
                 state,
@@ -53898,7 +54556,7 @@
          * Builds the current frame snapshot from the latest state.
          */
         function buildFrameLines() {
-            return buildCoderRunUiFrame({
+            return buildFrameLinesFromState({
                 terminalWidth: getTerminalWidth(),
                 animationFrame: spinnerFrame,
                 spinner: SPINNER_FRAMES[spinnerFrame],
@@ -53910,6 +54568,7 @@
                 maxAttempts: state.maxAttempts,
                 statusMessage: state.statusMessage,
                 detailLines: state.detailLines,
+                messagePreviewLines: state.messagePreviewLines,
                 pendingEnterLabel: state.pendingEnterLabel,
                 agentOutputLines: state.agentOutputLines,
                 errors: state.errors,
@@ -58990,7 +59649,7 @@
      */
     function buildAgentMessageScriptPath(projectPath, messageFile) {
         const scriptFileName = `${messageFile.fileName.replace(/\.[^.]+$/u, '')}.sh`;
-        return path.join(projectPath, '.tmp', 'agent-messages', scriptFileName);
+        return resolvePromptbookTempPath(projectPath, 'scripts', 'agent-messages', scriptFileName);
     }
 
     /**
@@ -59046,6 +59705,242 @@
             (error.code === 'ENOENT' || error.code === 'ENOTDIR'));
     }
 
+    /**
+     * Compact 3x5 block font used for agent-name initials in the terminal dashboard.
+     */
+    const BLOCK_FONT = {
+        A: ['███', '█ █', '███', '█ █', '█ █'],
+        B: ['██ ', '█ █', '██ ', '█ █', '██ '],
+        C: ['███', '█  ', '█  ', '█  ', '███'],
+        D: ['██ ', '█ █', '█ █', '█ █', '██ '],
+        E: ['███', '█  ', '██ ', '█  ', '███'],
+        F: ['███', '█  ', '██ ', '█  ', '█  '],
+        G: ['███', '█  ', '█ ██', '█  █', '████'],
+        H: ['█ █', '█ █', '███', '█ █', '█ █'],
+        I: ['███', ' █ ', ' █ ', ' █ ', '███'],
+        J: ['███', '  █', '  █', '█ █', '██ '],
+        K: ['█ █', '█ █', '██ ', '█ █', '█ █'],
+        L: ['█  ', '█  ', '█  ', '█  ', '███'],
+        M: ['█ █', '███', '███', '█ █', '█ █'],
+        N: ['█ █', '███', '███', '███', '█ █'],
+        O: ['███', '█ █', '█ █', '█ █', '███'],
+        P: ['███', '█ █', '███', '█  ', '█  '],
+        Q: ['███', '█ █', '█ █', '███', '  █'],
+        R: ['███', '█ █', '███', '██ ', '█ █'],
+        S: ['███', '█  ', '███', '  █', '███'],
+        T: ['███', ' █ ', ' █ ', ' █ ', ' █ '],
+        U: ['█ █', '█ █', '█ █', '█ █', '███'],
+        V: ['█ █', '█ █', '█ █', '█ █', ' █ '],
+        W: ['█ █', '█ █', '███', '███', '█ █'],
+        X: ['█ █', '█ █', ' █ ', '█ █', '█ █'],
+        Y: ['█ █', '█ █', ' █ ', ' █ ', ' █ '],
+        Z: ['███', '  █', ' █ ', '█  ', '███'],
+        0: ['███', '█ █', '█ █', '█ █', '███'],
+        1: [' ██', '  █', '  █', '  █', '███'],
+        2: ['███', '  █', '███', '█  ', '███'],
+        3: ['███', '  █', ' ██', '  █', '███'],
+        4: ['█ █', '█ █', '███', '  █', '  █'],
+        5: ['███', '█  ', '███', '  █', '███'],
+        6: ['███', '█  ', '███', '█ █', '███'],
+        7: ['███', '  █', '  █', '  █', '  █'],
+        8: ['███', '█ █', '███', '█ █', '███'],
+        9: ['███', '█ █', '███', '  █', '███'],
+    };
+    /**
+     * Fallback glyph used when the initials contain unsupported characters.
+     */
+    const UNKNOWN_LETTER = ['███', '  █', ' ██', '   ', ' ██'];
+    /**
+     * Builds a compact centered initials banner for `ptbk agent run`.
+     */
+    function buildAgentRunInitialsVisual(agentName, totalWidth) {
+        const initials = extractAgentInitials(agentName);
+        const glyphRows = Array.from({ length: 5 }, () => '');
+        for (const initial of initials) {
+            const glyph = BLOCK_FONT[initial] || UNKNOWN_LETTER;
+            for (let rowIndex = 0; rowIndex < glyph.length; rowIndex++) {
+                glyphRows[rowIndex] = `${glyphRows[rowIndex]}${glyph[rowIndex]}  `;
+            }
+        }
+        const trimmedGlyphRows = glyphRows.map((glyphRow) => glyphRow.trimEnd());
+        const visualWidth = trimmedGlyphRows.reduce((maxWidth, glyphRow) => Math.max(maxWidth, visibleLength(glyphRow)), 0);
+        return trimmedGlyphRows.map((glyphRow, rowIndex) => {
+            const coloredRow = rowIndex === 2 ? colors__default["default"].cyan.bold(glyphRow) : rowIndex === 0 ? colors__default["default"].blue.bold(glyphRow) : colors__default["default"].white.bold(glyphRow);
+            return centerAnsiText(padAnsiText(coloredRow, visualWidth), totalWidth);
+        });
+    }
+    /**
+     * Extracts readable initials from the local agent title.
+     */
+    function extractAgentInitials(agentName) {
+        const normalizedAlphanumericName = agentName.replace(/[^A-Za-z0-9]/gu, '').toUpperCase();
+        const words = agentName
+            .trim()
+            .split(/[^A-Za-z0-9]+/u)
+            .filter(Boolean)
+            .map((word) => word[0].toUpperCase());
+        if (words.length > 1) {
+            return words.slice(0, 3);
+        }
+        const fallbackLetters = normalizedAlphanumericName.slice(0, 2).split('');
+        return fallbackLetters.length > 0 ? fallbackLetters : ['A'];
+    }
+
+    /**
+     * Minimum width used for the rich agent-run frame.
+     */
+    const MIN_FRAME_WIDTH = 56;
+    /**
+     * Maximum width used for the rich agent-run frame.
+     */
+    const MAX_FRAME_WIDTH = 96;
+    /**
+     * Maximum number of source-message lines shown in the dedicated preview box.
+     */
+    const MAX_MESSAGE_PREVIEW_LINES = 6;
+    /**
+     * Builds the complete boxed terminal frame for the rich `ptbk agent run` UI.
+     */
+    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__default["default"].yellow(`${options.spinner} `)}` : '';
+        const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.statusMessage);
+        const sessionLines = buildSessionLines(options, totalWidth, pausePresentation);
+        const currentTaskLines = options.currentPromptLabel
+            ? [
+                `${promptStatusPrefix}${colors__default["default"].bold.white(fitPlainText(options.currentPromptLabel, totalWidth - 8))}`,
+                `Attempt ${options.currentAttempt}/${options.maxAttempts}  ·  ${options.statusMessage}`,
+                ...options.detailLines.map((detailLine) => `• ${detailLine}`),
+            ]
+            : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
+        const userMessageLines = buildUserMessagePreviewLines(options.messagePreviewLines, totalWidth);
+        const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
+        const controls = buildControlPills(pausePresentation.pauseControl, options.pendingEnterLabel).join('  ');
+        const frame = [
+            ...buildAgentRunInitialsVisual(options.config.localAgentName || 'Local Agent', totalWidth),
+            '',
+            ...renderBox('Session', sessionLines, totalWidth, colors__default["default"].yellow.bold),
+            ...renderBox('Current task', currentTaskLines, totalWidth, colors__default["default"].magenta.bold),
+            ...renderBox('User message', userMessageLines, totalWidth, colors__default["default"].cyan.bold),
+            ...renderBox('Live output', visibleOutputLines, totalWidth, colors__default["default"].green.bold),
+        ];
+        if (options.errors.length > 0) {
+            frame.push(...renderBox('Errors', options.errors.map((errorLine) => `${colors__default["default"].red('✗')} ${errorLine}`), totalWidth, colors__default["default"].red.bold));
+        }
+        frame.push(...renderBox('Controls', [controls], totalWidth, colors__default["default"].white.bold));
+        return frame;
+    }
+    /**
+     * Builds the structured session lines for the agent-specific dashboard.
+     */
+    function buildSessionLines(options, totalWidth, pausePresentation) {
+        const bodyWidth = Math.max(10, totalWidth - 4);
+        const finishedMessages = options.progress.sessionDone;
+        const queuedMessages = options.progress.sessionRemaining;
+        const totalMessages = options.progress.sessionTotal;
+        const localAgentName = options.config.localAgentName || 'Local Agent';
+        const runnerParts = [options.config.agentName || 'No runner selected'];
+        if (options.config.modelName) {
+            runnerParts.push(options.config.modelName);
+        }
+        if (options.config.thinkingLevel) {
+            runnerParts.push(`thinking ${options.config.thinkingLevel}`);
+        }
+        const sessionRows = [
+            {
+                label: 'State',
+                value: `${pausePresentation.badge} ${pausePresentation.stateMessage}`,
+            },
+            {
+                label: 'Agent',
+                value: localAgentName,
+            },
+            {
+                label: 'Runner',
+                value: runnerParts.join('  ·  '),
+            },
+            {
+                label: 'Queue',
+                value: `${totalMessages} total  ·  ${finishedMessages} finished  ·  ${queuedMessages} queued`,
+            },
+            {
+                label: 'Timing',
+                value: `Elapsed ${options.progress.elapsedText}  ·  Total ${options.progress.estimatedTotalText}  ·  ETA ${options.progress.estimatedLabel}`,
+            },
+            {
+                label: 'Progress',
+                value: buildProgressBar$1(options.progress.percentage, bodyWidth - SESSION_LABEL_WIDTH - 1, `${options.progress.percentage}% complete (${finishedMessages}/${totalMessages || 0} finished)`),
+            },
+        ];
+        return sessionRows.map((sessionRow) => buildLabeledSessionLine(sessionRow.label, sessionRow.value, bodyWidth));
+    }
+    /**
+     * Fits the most recent user message into a fixed-height panel while preserving line breaks.
+     */
+    function buildUserMessagePreviewLines(messagePreviewLines, totalWidth) {
+        const previewWidth = Math.max(10, totalWidth - 4);
+        const rawLines = messagePreviewLines && messagePreviewLines.length > 0
+            ? messagePreviewLines.map((messagePreviewLine) => messagePreviewLine.replace(/\t/gu, '    '))
+            : ['No `MESSAGE @User` content found in the queued message.'];
+        const visibleLines = rawLines.slice(0, MAX_MESSAGE_PREVIEW_LINES).map((line) => fitPlainText(line, previewWidth));
+        if (rawLines.length > MAX_MESSAGE_PREVIEW_LINES) {
+            visibleLines[MAX_MESSAGE_PREVIEW_LINES - 1] = fitPlainText(`${visibleLines[MAX_MESSAGE_PREVIEW_LINES - 1]} …`, previewWidth);
+        }
+        while (visibleLines.length < MAX_MESSAGE_PREVIEW_LINES) {
+            visibleLines.push('');
+        }
+        return visibleLines;
+    }
+
+    /**
+     * Reads the local agent title and latest queued user message for the rich agent dashboard.
+     */
+    async function loadAgentRunUiMetadata(projectPath, queuedMessage) {
+        const [localAgentName, queuedMessageContent] = await Promise.all([
+            readLocalAgentName(projectPath),
+            promises.readFile(queuedMessage.absolutePath, 'utf-8'),
+        ]);
+        return {
+            localAgentName,
+            latestUserMessageLines: extractLatestUserMessageLines(queuedMessageContent),
+        };
+    }
+    /**
+     * Reads the local `agent.book` title and falls back to a stable generic name when unavailable.
+     */
+    async function readLocalAgentName(projectPath) {
+        try {
+            const agentSource = await promises.readFile(path.join(projectPath, AGENT_BOOK_FILE_PATH), 'utf-8');
+            return parseAgentSourceWithCommitments(agentSource).agentName || 'Local Agent';
+        }
+        catch (error) {
+            if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                (error.code === 'ENOENT' || error.code === 'ENOTDIR')) {
+                return 'Local Agent';
+            }
+            throw error;
+        }
+    }
+    /**
+     * Extracts the latest `MESSAGE @User` block while preserving the original line breaks.
+     */
+    function extractLatestUserMessageLines(messageContent) {
+        const messageBlockPattern = /^MESSAGE\s+@User\b[^\n]*\n([\s\S]*?)(?=^MESSAGE\s+@|(?![\s\S]))/gmu;
+        let latestMatch = null;
+        while (true) {
+            const currentMatch = messageBlockPattern.exec(messageContent);
+            if (!currentMatch) {
+                break;
+            }
+            latestMatch = currentMatch;
+        }
+        const latestUserMessageContent = ((latestMatch === null || latestMatch === void 0 ? void 0 : latestMatch[1]) || messageContent).trim();
+        return latestUserMessageContent.length > 0 ? latestUserMessageContent.split(/\r?\n/gu) : [];
+    }
+
     /**
      * Converts `ptbk agent` options into the shared runner option shape.
      */
@@ -59094,7 +59989,8 @@
     async function tickAgentMessages(options, tickOptions = {}) {
         validateAgentRunOptions(options);
         const projectPath = process.cwd();
-        let queuedMessage = await findNextQueuedMessage(projectPath);
+        let queueSnapshot = await loadAgentMessageQueueSnapshot(projectPath);
+        let queuedMessage = queueSnapshot.queuedMessages[0];
         if (!queuedMessage) {
             announceNoQueuedMessages(tickOptions);
             return { isMessageProcessed: false };
@@ -59103,7 +59999,8 @@
             await ensureCleanQueueIfNeeded(projectPath, options);
             console.info(colors__default["default"].gray('Pulling latest changes before answering the next message...'));
             await pullLatestChanges();
-            queuedMessage = await findNextQueuedMessage(projectPath);
+            queueSnapshot = await loadAgentMessageQueueSnapshot(projectPath);
+            queuedMessage = queueSnapshot.queuedMessages[0];
             if (!queuedMessage) {
                 announceNoQueuedMessages(tickOptions);
                 return { isMessageProcessed: false };
@@ -59112,7 +60009,8 @@
         await ensureCleanQueueIfNeeded(projectPath, options);
         const sharedRunOptions = createCoderRunOptionsForAgent(options);
         const { runner, actualRunnerModel } = resolvePromptRunner(sharedRunOptions);
-        const uiHandle = createAgentRunUiHandle(options, runner, actualRunnerModel, queuedMessage);
+        const agentUiMetadata = await loadAgentRunUiMetadata(projectPath, queuedMessage);
+        const uiHandle = createAgentRunUiHandle(options, runner, actualRunnerModel, queuedMessage, queueSnapshot, agentUiMetadata);
         try {
             const finishedMessage = await runQueuedAgentMessage({
                 projectPath,
@@ -59121,6 +60019,10 @@
                 queuedMessage,
                 uiHandle,
             });
+            uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.updateProgress(createAgentQueueProgressSnapshot({
+                finishedMessageCount: queueSnapshot.finishedMessageCount + 1,
+                queuedMessages: queueSnapshot.queuedMessages.slice(1),
+            }));
             uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Message answered');
             uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('done');
             return {
@@ -59189,24 +60091,21 @@
     /**
      * Creates and seeds the rich terminal UI for an agent message run.
      */
-    function createAgentRunUiHandle(options, runner, actualRunnerModel, queuedMessage) {
+    function createAgentRunUiHandle(options, runner, actualRunnerModel, queuedMessage, queueSnapshot, agentUiMetadata) {
         if (options.noUi || !process.stdout.isTTY) {
             return undefined;
         }
-        const uiHandle = renderCoderRunUi(moment__default["default"]());
+        const uiHandle = renderCoderRunUi(moment__default["default"](), { buildFrameLines: buildAgentRunUiFrame });
         uiHandle.state.setConfig({
             agentName: runner.name,
+            localAgentName: agentUiMetadata.localAgentName,
             modelName: actualRunnerModel,
             thinkingLevel: options.thinkingLevel,
             priority: 0,
         });
-        uiHandle.state.updateProgress({
-            done: 0,
-            forAgent: 1,
-            belowMinimumPriority: 0,
-            toBeWritten: 0,
-        });
+        uiHandle.state.updateProgress(createAgentQueueProgressSnapshot(queueSnapshot));
         uiHandle.state.setCurrentPrompt(queuedMessage.relativePath);
+        uiHandle.state.setMessagePreviewLines([...agentUiMetadata.latestUserMessageLines]);
         uiHandle.state.setPhase('loading');
         uiHandle.state.setStatusMessage('Preparing message');
         return uiHandle;
@@ -59236,11 +60135,15 @@
         return [finishedMessage.relativePath];
     }
     /**
-     * Finds the next queued message or returns undefined when the queue is empty.
+     * Converts agent queue counts into the prompt-style snapshot used by the shared rich UI state.
      */
-    async function findNextQueuedMessage(projectPath) {
-        const queuedMessages = await listQueuedAgentMessages(projectPath);
-        return queuedMessages[0];
+    function createAgentQueueProgressSnapshot(queueSnapshot) {
+        return {
+            done: queueSnapshot.finishedMessageCount,
+            forAgent: queueSnapshot.queuedMessages.length,
+            belowMinimumPriority: 0,
+            toBeWritten: 0,
+        };
     }
     /**
      * Runs the clean working tree guard unless the user explicitly disabled it.
@@ -59281,6 +60184,38 @@
         }
         console.info(colors__default["default"].gray('No queued agent messages.'));
     }
+    /**
+     * Reads current queued and finished message counts for the agent dashboard.
+     */
+    async function loadAgentMessageQueueSnapshot(projectPath) {
+        const [queuedMessages, finishedMessageCount] = await Promise.all([
+            listQueuedAgentMessages(projectPath),
+            countMarkdownFiles(path.join(projectPath, AGENT_FINISHED_MESSAGES_DIRECTORY_PATH)),
+        ]);
+        return {
+            queuedMessages,
+            finishedMessageCount,
+        };
+    }
+    /**
+     * Counts markdown files inside one queue directory and treats a missing directory as empty.
+     */
+    async function countMarkdownFiles(directoryPath) {
+        try {
+            const directoryEntries = await promises.readdir(directoryPath, { withFileTypes: true });
+            return directoryEntries.filter((directoryEntry) => directoryEntry.isFile() && /\.m(?:d|arkdown)$/iu.test(directoryEntry.name))
+                .length;
+        }
+        catch (error) {
+            if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                (error.code === 'ENOENT' || error.code === 'ENOTDIR')) {
+                return 0;
+            }
+            throw error;
+        }
+    }
 
     var tickAgentMessages$1 = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -59409,11 +60344,11 @@
     /**
      * Default ignored paths while scanning the repository.
      */
-    const DEFAULT_IGNORE_GLOBS = ['**/node_modules/**', '**/.git/**', '**/.promptbook/ptbk-coder/**'];
+    const DEFAULT_IGNORE_GLOBS = ['**/node_modules/**', '**/.git/**', `**/${getPromptbookTempPosixPath('ptbk-coder')}/**`];
     /**
      * Directory used for Promptbook coder runtime caches.
      */
-    const PTBK_CODER_CACHE_DIRECTORY_PATH = '.promptbook/ptbk-coder';
+    const PTBK_CODER_CACHE_DIRECTORY_PATH = getPromptbookTempPath('ptbk-coder');
     /**
      * Relative cache file path storing per-file emoji-tag scan results.
      */