@promptbook/cli 0.112.0-103 → 0.112.0-105

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-103';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-105';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1748,6 +1748,12 @@ const AGENT_QUEUED_MESSAGES_DIRECTORY_PATH = join(AGENT_MESSAGES_DIRECTORY_PATH,
  * @private internal utility of `ptbk agent-folder`
  */
 const AGENT_FINISHED_MESSAGES_DIRECTORY_PATH = join(AGENT_MESSAGES_DIRECTORY_PATH, 'finished');
+/**
+ * Relative path to messages that the agent runner stopped retrying.
+ *
+ * @private internal utility of `ptbk agent-folder`
+ */
+const AGENT_FAILED_MESSAGES_DIRECTORY_PATH = join(AGENT_MESSAGES_DIRECTORY_PATH, 'failed');
 /**
  * Relative path to generated local agent documentation initialized by `ptbk agent-folder init`.
  *
@@ -3158,12 +3164,38 @@ const AGENTS_SERVER_BUILD_INPUT_EXCLUDED_DIRECTORY_NAMES = new Set([
     'playwright-report',
     'test-results',
 ]);
+/**
+ * Runtime source files excluded from the packaged Agents Server copy.
+ *
+ * @private internal constant of `ptbk agents-server`
+ */
+const AGENTS_SERVER_BUILD_INPUT_EXCLUDED_SOURCE_PATHS = new Set([
+    'src/_packages/browser.index.ts',
+    'src/_packages/browser.readme.md',
+    'src/llm-providers/_common/register/$provideLlmToolsForTestingAndScriptsAndPlayground.ts',
+    'src/llm-providers/_common/utils/assertUniqueModels.ts',
+]);
+/**
+ * Runtime source folders excluded from the packaged Agents Server copy.
+ *
+ * @private internal constant of `ptbk agents-server`
+ */
+const AGENTS_SERVER_BUILD_INPUT_EXCLUDED_SOURCE_PATH_PREFIXES = [
+    'src/dialogs/simple-prompt',
+    'src/storage/local-storage',
+];
 /**
  * Test files copied out of packaged runtime input paths because Next does not build them.
  *
  * @private internal constant of `ptbk agents-server`
  */
-const AGENTS_SERVER_BUILD_INPUT_TEST_FILE_PATTERN = /\.(?:spec|test)\.[jt]sx?$/iu;
+const AGENTS_SERVER_BUILD_INPUT_TEST_FILE_PATTERN = /\.(?:spec|test)(?:\.|$)/iu;
+/**
+ * Type-only compile check files copied out of packaged runtime input paths.
+ *
+ * @private internal constant of `ptbk agents-server`
+ */
+const AGENTS_SERVER_BUILD_INPUT_TEST_TYPE_FILE_PATTERN = /\.test-type\.[jt]sx?$/iu;
 /**
  * Ensures that the local Agents Server production build exists and matches its source fingerprint.
  *
@@ -3358,15 +3390,48 @@ async function copyAgentsServerRuntimePath(options) {
  */
 function shouldCopyAgentsServerRuntimePath(sourcePath, sourceRootPath) {
     const sourceRelativePath = relative(sourceRootPath, sourcePath).replace(/\\/gu, '/');
+    const sourceRuntimeRelativePath = normalizeRuntimeSourceRelativePath(sourcePath, sourceRootPath);
     const sourcePathSegments = sourceRelativePath.split('/').filter(Boolean);
     const sourceBasename = basename(sourcePath);
     if (sourcePathSegments.some((sourcePathSegment) => AGENTS_SERVER_BUILD_INPUT_EXCLUDED_DIRECTORY_NAMES.has(sourcePathSegment))) {
         return false;
     }
+    if (sourcePathSegments.includes('playground')) {
+        return false;
+    }
+    if (isExcludedAgentsServerRuntimeSourcePath(sourceRuntimeRelativePath)) {
+        return false;
+    }
     if (sourceBasename.startsWith('.env')) {
         return false;
     }
-    return !AGENTS_SERVER_BUILD_INPUT_TEST_FILE_PATTERN.test(sourceBasename);
+    return (!AGENTS_SERVER_BUILD_INPUT_TEST_FILE_PATTERN.test(sourceBasename) &&
+        !AGENTS_SERVER_BUILD_INPUT_TEST_TYPE_FILE_PATTERN.test(sourceBasename));
+}
+/**
+ * Normalizes a copied runtime path to the shape used inside the packaged runtime root.
+ */
+function normalizeRuntimeSourceRelativePath(sourcePath, sourceRootPath) {
+    const sourceRelativePath = relative(sourceRootPath, sourcePath).replace(/\\/gu, '/');
+    const sourceRootBasename = basename(sourceRootPath);
+    if (!sourceRelativePath) {
+        return sourceRootBasename;
+    }
+    return `${sourceRootBasename}/${sourceRelativePath}`;
+}
+/**
+ * Checks whether one normalized runtime path is equal to or nested below another path.
+ */
+function isRuntimePathWithin(sourceRuntimeRelativePath, excludedSourcePathPrefix) {
+    return (sourceRuntimeRelativePath === excludedSourcePathPrefix ||
+        sourceRuntimeRelativePath.startsWith(`${excludedSourcePathPrefix}/`));
+}
+/**
+ * Returns true for runtime source files and folders that are not needed by the Agents Server build.
+ */
+function isExcludedAgentsServerRuntimeSourcePath(sourceRuntimeRelativePath) {
+    return (AGENTS_SERVER_BUILD_INPUT_EXCLUDED_SOURCE_PATHS.has(sourceRuntimeRelativePath) ||
+        AGENTS_SERVER_BUILD_INPUT_EXCLUDED_SOURCE_PATH_PREFIXES.some((excludedSourcePathPrefix) => isRuntimePathWithin(sourceRuntimeRelativePath, excludedSourcePathPrefix)));
 }
 /**
  * Links the materialized runtime back to the package dependency tree used by the installed CLI.
@@ -3484,6 +3549,9 @@ async function createAgentsServerBuildSourceFingerprint(appPath) {
  * Adds one runtime source file or directory subtree to the production build fingerprint.
  */
 async function addAgentsServerBuildInputToFingerprint(fingerprint, options) {
+    if (isExcludedAgentsServerBuildInputPath(options.inputPath, options.runtimeRootPath)) {
+        return;
+    }
     let inputStats;
     try {
         inputStats = await stat(options.inputPath);
@@ -3493,9 +3561,6 @@ async function addAgentsServerBuildInputToFingerprint(fingerprint, options) {
         return;
     }
     if (inputStats.isFile()) {
-        if (isExcludedAgentsServerBuildInputFile(options.inputPath)) {
-            return;
-        }
         fingerprint.update(`file:${normalizeBuildInputPath(options.runtimeRootPath, options.inputPath)}\n`);
         fingerprint.update(await readFile(options.inputPath));
         fingerprint.update('\n');
@@ -3518,10 +3583,23 @@ async function addAgentsServerBuildInputToFingerprint(fingerprint, options) {
     }
 }
 /**
- * Returns true for non-build test files inside shared runtime source paths.
+ * Returns true for non-build files and folders inside shared runtime source paths.
  */
-function isExcludedAgentsServerBuildInputFile(inputPath) {
-    return AGENTS_SERVER_BUILD_INPUT_TEST_FILE_PATTERN.test(basename(inputPath));
+function isExcludedAgentsServerBuildInputPath(inputPath, runtimeRootPath) {
+    const inputRelativePath = normalizeBuildInputPath(runtimeRootPath, inputPath);
+    const inputPathSegments = inputRelativePath.split('/').filter(Boolean);
+    const inputBasename = basename(inputPath);
+    if (inputPathSegments.some((inputPathSegment) => AGENTS_SERVER_BUILD_INPUT_EXCLUDED_DIRECTORY_NAMES.has(inputPathSegment))) {
+        return true;
+    }
+    if (inputPathSegments.includes('playground')) {
+        return true;
+    }
+    if (isExcludedAgentsServerRuntimeSourcePath(inputRelativePath)) {
+        return true;
+    }
+    return (AGENTS_SERVER_BUILD_INPUT_TEST_FILE_PATTERN.test(inputBasename) ||
+        AGENTS_SERVER_BUILD_INPUT_TEST_TYPE_FILE_PATTERN.test(inputBasename));
 }
 /**
  * Normalizes one absolute runtime path so cache fingerprints are stable across platforms.
@@ -4942,7 +5020,7 @@ async function listQueuedAgentMessages(projectPath) {
         .filter((entry) => entry.isFile() && isBookFileName(entry.name))
         .map((entry) => ({
         absolutePath: join(queuedMessagesDirectoryPath, entry.name),
-        relativePath: normalizeRelativePath$1(join(AGENT_QUEUED_MESSAGES_DIRECTORY_PATH, entry.name)),
+        relativePath: normalizeRelativePath$2(join(AGENT_QUEUED_MESSAGES_DIRECTORY_PATH, entry.name)),
         fileName: entry.name,
     }))
         .sort((firstMessage, secondMessage) => firstMessage.fileName.localeCompare(secondMessage.fileName));
@@ -4970,7 +5048,7 @@ function isBookFileName(fileName) {
 /**
  * Normalizes a relative path for Markdown links and Git path matching.
  */
-function normalizeRelativePath$1(relativePath) {
+function normalizeRelativePath$2(relativePath) {
     return relativePath.replace(/\\/gu, '/');
 }
 /**
@@ -11041,7 +11119,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,
@@ -11253,7 +11331,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,
         };
     });
@@ -12444,7 +12522,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,
@@ -12654,7 +12732,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,
             });
@@ -12843,7 +12921,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,
@@ -12992,7 +13070,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`,
             });
@@ -13092,6 +13170,514 @@ 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.
@@ -13862,6 +14448,7 @@ const AVATAR_VISUALS = [
     octopus3AvatarVisual,
     octopus3dAvatarVisual,
     octopus3d2AvatarVisual,
+    octopus3d3AvatarVisual,
     asciiOctopusAvatarVisual,
     minecraftAvatarVisual,
     minecraft2AvatarVisual,
@@ -34567,7 +35154,7 @@ function buildAgentMessageScriptPath(projectPath, messageFile) {
 async function moveAgentMessageToFinished(projectPath, messageFile) {
     const finishedDirectoryPath = join(projectPath, AGENT_FINISHED_MESSAGES_DIRECTORY_PATH);
     const finishedMessagePath = join(finishedDirectoryPath, messageFile.fileName);
-    const finishedMessageRelativePath = normalizeRelativePath(join(AGENT_FINISHED_MESSAGES_DIRECTORY_PATH, messageFile.fileName));
+    const finishedMessageRelativePath = normalizeRelativePath$1(join(AGENT_FINISHED_MESSAGES_DIRECTORY_PATH, messageFile.fileName));
     await mkdir(finishedDirectoryPath, { recursive: true });
     if (await isExistingPath(finishedMessagePath)) {
         await rm(finishedMessagePath, { force: true });
@@ -34597,7 +35184,7 @@ async function isExistingPath(path) {
 /**
  * Normalizes a relative path for Git and display.
  */
-function normalizeRelativePath(relativePath) {
+function normalizeRelativePath$1(relativePath) {
     return relativePath.replace(/\\/gu, '/');
 }
 /**
@@ -35616,6 +36203,177 @@ function validateAgentWatchOptions(commandDisplayName, options) {
         `));
 }
 
+/**
+ * Moves one repeatedly failing queued message to `messages/failed` with a visible agent failure reply.
+ */
+async function moveAgentMessageToFailed(options) {
+    const { projectPath, messageFile, failureReason } = options;
+    const failedDirectoryPath = join(projectPath, AGENT_FAILED_MESSAGES_DIRECTORY_PATH);
+    const failedMessagePath = join(failedDirectoryPath, messageFile.fileName);
+    const failedMessageRelativePath = normalizeRelativePath(join(AGENT_FAILED_MESSAGES_DIRECTORY_PATH, messageFile.fileName));
+    const queuedMessageContent = await readFile(messageFile.absolutePath, 'utf-8');
+    await mkdir(failedDirectoryPath, { recursive: true });
+    await rm(failedMessagePath, { force: true });
+    await rename(messageFile.absolutePath, failedMessagePath);
+    await writeFile(failedMessagePath, appendFailureReply(queuedMessageContent, failureReason), 'utf-8');
+    return {
+        absolutePath: failedMessagePath,
+        relativePath: failedMessageRelativePath,
+        fileName: messageFile.fileName,
+    };
+}
+/**
+ * Appends a synthetic `@Agent` reply so the Agents Server can display the terminal failure reason.
+ */
+function appendFailureReply(bookContent, failureReason) {
+    const normalizedBookContent = bookContent.trimEnd();
+    const normalizedFailureReason = failureReason.trim();
+    return `${normalizedBookContent}\n\nMESSAGE @Agent\n${normalizedFailureReason}\n`;
+}
+/**
+ * Normalizes a relative path for Git and display.
+ */
+function normalizeRelativePath(relativePath) {
+    return relativePath.replace(/\\/gu, '/');
+}
+
+/**
+ * Default number of failed queued-message attempts allowed before the watcher stops retrying that message.
+ */
+const DEFAULT_MAX_MESSAGE_PROCESSING_FAILURES = 3;
+/**
+ * Maximum number of characters copied from the final runner error into the failed chat message.
+ */
+const MAX_FAILED_MESSAGE_ERROR_DETAILS_LENGTH = 4000;
+/**
+ * Tracks repeated watch-level failures for queued message files and stops retrying them after a configured cap.
+ */
+class AgentMessageFailureTracker {
+    constructor(options = {}) {
+        this.failuresByMessageKey = new Map();
+        this.maxMessageProcessingFailures = normalizeMaxMessageProcessingFailures(options.maxMessageProcessingFailures);
+    }
+    /**
+     * Clears the failure counter after a queued message is processed successfully.
+     */
+    clearMessageFailure(projectPath, messageFile) {
+        if (!messageFile) {
+            return;
+        }
+        this.failuresByMessageKey.delete(createAgentMessageFailureKey(projectPath, messageFile.relativePath));
+    }
+    /**
+     * Records one queued-message failure and moves the message into `messages/failed` when the retry cap is reached.
+     */
+    async recordFailure(error) {
+        var _a, _b;
+        const errorContext = getAgentWatchErrorContext(error);
+        if (!(errorContext === null || errorContext === void 0 ? void 0 : errorContext.projectPath) || !errorContext.queuedMessageRelativePath) {
+            return null;
+        }
+        const messageKey = createAgentMessageFailureKey(errorContext.projectPath, errorContext.queuedMessageRelativePath);
+        const previousFailureCount = (_b = (_a = this.failuresByMessageKey.get(messageKey)) === null || _a === void 0 ? void 0 : _a.failureCount) !== null && _b !== void 0 ? _b : 0;
+        const failureCount = previousFailureCount + 1;
+        if (failureCount < this.maxMessageProcessingFailures) {
+            this.failuresByMessageKey.set(messageKey, { failureCount });
+            return {
+                failureCount,
+                maxMessageProcessingFailures: this.maxMessageProcessingFailures,
+                isMessageMovedToFailed: false,
+            };
+        }
+        try {
+            await moveAgentMessageToFailed({
+                projectPath: errorContext.projectPath,
+                messageFile: createAgentMessageFileFromContext(errorContext.projectPath, errorContext.queuedMessageRelativePath),
+                failureReason: buildFailedQueuedMessageReason({
+                    error,
+                    failureCount,
+                    maxMessageProcessingFailures: this.maxMessageProcessingFailures,
+                }),
+            });
+            this.failuresByMessageKey.delete(messageKey);
+            console.error(colors.yellow(`Moved ${errorContext.queuedMessageRelativePath} to messages/failed after ${failureCount} failed attempt(s).`));
+        }
+        catch (moveError) {
+            this.failuresByMessageKey.set(messageKey, { failureCount });
+            console.error(colors.yellow(`Failed to move ${errorContext.queuedMessageRelativePath} to messages/failed: ${formatUnknownErrorDetails(moveError)}`));
+            return {
+                failureCount,
+                maxMessageProcessingFailures: this.maxMessageProcessingFailures,
+                isMessageMovedToFailed: false,
+            };
+        }
+        return {
+            failureCount,
+            maxMessageProcessingFailures: this.maxMessageProcessingFailures,
+            isMessageMovedToFailed: true,
+        };
+    }
+}
+/**
+ * Creates the stable in-memory key for one queued message.
+ */
+function createAgentMessageFailureKey(projectPath, queuedMessageRelativePath) {
+    return `${projectPath}\0${queuedMessageRelativePath}`;
+}
+/**
+ * Recreates the selected queued message descriptor from watch-loop error context.
+ */
+function createAgentMessageFileFromContext(projectPath, queuedMessageRelativePath) {
+    return {
+        absolutePath: join(projectPath, queuedMessageRelativePath),
+        relativePath: queuedMessageRelativePath.replace(/\\/gu, '/'),
+        fileName: getFileNameFromRelativePath(queuedMessageRelativePath),
+    };
+}
+/**
+ * Extracts the filename from a normalized or platform-specific relative path.
+ */
+function getFileNameFromRelativePath(relativePath) {
+    const pathParts = relativePath.replace(/\\/gu, '/').split('/');
+    return pathParts[pathParts.length - 1] || 'message.book';
+}
+/**
+ * Builds the message shown to the chat user when the local runner stops retrying.
+ */
+function buildFailedQueuedMessageReason(options) {
+    const errorDetails = limitFailureDetails(formatUnknownErrorDetails(options.error));
+    return spaceTrim$1((block) => `
+            Local agent runner failed after ${options.failureCount} attempt(s) and stopped retrying.
+
+            Fix the runner or API configuration before trying again. The maximum failed-attempt limit is currently ${options.maxMessageProcessingFailures}.
+
+            Last runner error:
+            \`\`\`
+            ${block(errorDetails)}
+            \`\`\`
+        `);
+}
+/**
+ * Keeps the synthetic failed chat message bounded even when runner logs are long.
+ */
+function limitFailureDetails(errorDetails) {
+    const normalizedErrorDetails = errorDetails.trim();
+    if (normalizedErrorDetails.length <= MAX_FAILED_MESSAGE_ERROR_DETAILS_LENGTH) {
+        return normalizedErrorDetails;
+    }
+    return spaceTrim$1(`
+        [...runner error truncated to the last ${MAX_FAILED_MESSAGE_ERROR_DETAILS_LENGTH} characters...]
+        ${normalizedErrorDetails.slice(-MAX_FAILED_MESSAGE_ERROR_DETAILS_LENGTH)}
+    `);
+}
+/**
+ * Normalizes the retry cap used by standalone CLI runs when no server-provided limit is available.
+ */
+function normalizeMaxMessageProcessingFailures(rawValue) {
+    const parsedValue = Number(rawValue);
+    if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
+        return DEFAULT_MAX_MESSAGE_PROCESSING_FAILURES;
+    }
+    return Math.floor(parsedValue);
+}
+
 /**
  * Delay between multi-agent watch iterations while all queues stay empty.
  */
@@ -35652,6 +36410,9 @@ async function runMultipleAgentMessages(options, controls = {}) {
     let lastObservedProjectCount = 0;
     let isWatchSessionInitialized = false;
     let uiHandle;
+    const messageFailureTracker = new AgentMessageFailureTracker({
+        maxMessageProcessingFailures: options.maxMessageProcessingFailures,
+    });
     while (shouldContinue()) {
         try {
             if (!isWatchSessionInitialized) {
@@ -35700,7 +36461,7 @@ async function runMultipleAgentMessages(options, controls = {}) {
             const queuedProjects = projectSummaries.filter((projectSummary) => projectSummary.queuedMessageCount > 0);
             if (queuedProjects.length === 0) {
                 updateMultipleAgentRunUiForWatching(uiHandle, options, rootPath, projectSummaries, ignoredAgentCount);
-                await wait$2(MULTI_AGENT_QUEUE_POLL_INTERVAL_MS);
+                await wait$3(MULTI_AGENT_QUEUE_POLL_INTERVAL_MS);
                 continue;
             }
             if (!uiHandle) {
@@ -35740,6 +36501,9 @@ async function runMultipleAgentMessages(options, controls = {}) {
                     if (tickResult.value.tickResult.autoPullTimestamp !== undefined) {
                         autoPullTimestampsByProjectPath.set(tickResult.value.projectPath, tickResult.value.tickResult.autoPullTimestamp);
                     }
+                    if (tickResult.value.tickResult.isMessageProcessed) {
+                        messageFailureTracker.clearMessageFailure(tickResult.value.projectPath, tickResult.value.tickResult.queuedMessage);
+                    }
                     continue;
                 }
                 await handleAgentWatchError({
@@ -35747,6 +36511,7 @@ async function runMultipleAgentMessages(options, controls = {}) {
                     logDirectoryPath: controls.watchErrorLogDirectoryPath || rootPath,
                     error: tickResult.reason,
                 });
+                await messageFailureTracker.recordFailure(tickResult.reason);
             }
         }
         catch (error) {
@@ -35755,7 +36520,8 @@ async function runMultipleAgentMessages(options, controls = {}) {
                 logDirectoryPath: controls.watchErrorLogDirectoryPath || rootPath,
                 error,
             });
-            await wait$2(MULTI_AGENT_QUEUE_POLL_INTERVAL_MS);
+            await messageFailureTracker.recordFailure(error);
+            await wait$3(MULTI_AGENT_QUEUE_POLL_INTERVAL_MS);
         }
     }
 }
@@ -35839,7 +36605,9 @@ async function pullLatestChangesForLocalAgentRunnerProjectsIfNeeded(options) {
         const autoPullTimestamp = await pullLatestChangesForAgentQueueIfEnabled({
             projectPath,
             runOptions,
-            logMessage: uiHandle ? undefined : `Pulling latest changes in ${formatProjectPath(rootPath, projectPath)}...`,
+            logMessage: uiHandle
+                ? undefined
+                : `Pulling latest changes in ${formatProjectPath(rootPath, projectPath)}...`,
         });
         if (autoPullTimestamp !== undefined) {
             autoPullTimestampsByProjectPath.set(projectPath, autoPullTimestamp);
@@ -36053,9 +36821,7 @@ function buildMultiAgentUserMessageLines(projectSummaries, answeringProjectPaths
     const answeringMessageLines = projectSummaries
         .filter((projectSummary) => answeringProjectPaths.has(projectSummary.project.projectPath))
         .flatMap((projectSummary) => buildAnsweringAgentMessageLines(projectSummary));
-    return answeringMessageLines.length > 0
-        ? answeringMessageLines
-        : [WAITING_FOR_MESSAGE_LABEL];
+    return answeringMessageLines.length > 0 ? answeringMessageLines : [WAITING_FOR_MESSAGE_LABEL];
 }
 /**
  * Builds one dedicated message-preview panel per answering agent.
@@ -36146,7 +36912,7 @@ function formatProjectPath(rootPath, projectPath) {
 /**
  * Waits for the next idle poll interval in multi-agent watch mode.
  */
-async function wait$2(delayMs) {
+async function wait$3(delayMs) {
     await new Promise((resolve) => setTimeout(resolve, delayMs));
 }
 
@@ -36169,6 +36935,218 @@ async function withCurrentWorkingDirectory(directoryPath, callback) {
     }
 }
 
+/**
+ * Metadata key storing the delay between retry attempts when importing federated agent books.
+ *
+ * @private internal Agents Server constant
+ */
+const FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS_METADATA_KEY = 'FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS';
+/**
+ * Total number of attempts used when loading a federated imported agent before falling back.
+ *
+ * @private internal Agents Server constant
+ */
+const FEDERATED_AGENT_IMPORT_MAX_ATTEMPTS = 3;
+/**
+ * Default delay in milliseconds between federated imported-agent retry attempts.
+ *
+ * @private internal Agents Server constant
+ */
+const DEFAULT_FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS = 500;
+/**
+ * Default retry configuration for federated imported-agent loading.
+ *
+ * @private internal Agents Server constant
+ */
+Object.freeze({
+    maxAttempts: FEDERATED_AGENT_IMPORT_MAX_ATTEMPTS,
+    retryDelayMs: DEFAULT_FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS,
+});
+
+/**
+ * Metadata key used to persist tool-usage limits.
+ *
+ * @private shared constant for Agents Server
+ */
+const TOOL_USAGE_LIMITS_METADATA_KEY = 'TOOL_USAGE_LIMITS';
+/**
+ * Default timeout limits applied when administrators do not override them.
+ *
+ * @private shared constant for Agents Server
+ */
+const DEFAULT_TIMEOUT_TOOL_USAGE_LIMITS = {
+    maxActivePerChat: 5,
+    maxFiredPerDayPerChat: 10,
+};
+
+/**
+ * Legacy metadata key storing the maximum accepted file upload size in megabytes.
+ *
+ * @private shared Agents Server constant
+ */
+const MAX_FILE_UPLOAD_SIZE_MB_METADATA_KEY = 'MAX_FILE_UPLOAD_SIZE_MB';
+/**
+ * Default maximum accepted spawn depth in one tool-runtime context.
+ *
+ * @private shared Agents Server constant
+ */
+const DEFAULT_SPAWN_AGENT_MAX_DEPTH = 2;
+/**
+ * Default maximum number of spawned agents allowed per actor in one time window.
+ *
+ * @private shared Agents Server constant
+ */
+const DEFAULT_SPAWN_AGENT_RATE_LIMIT_MAX = 5;
+/**
+ * Default spawn rate-limit window size in milliseconds.
+ *
+ * @private shared Agents Server constant
+ */
+const DEFAULT_SPAWN_AGENT_RATE_LIMIT_WINDOW_MS = 10 * 60 * 1000;
+/**
+ * Default maximum number of failed local runner attempts before a queued message is moved to `messages/failed`.
+ *
+ * @private shared Agents Server constant
+ */
+const DEFAULT_LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS = 3;
+/**
+ * Stable keys used by the dedicated server-limits table.
+ *
+ * @private shared Agents Server constant
+ */
+const SERVER_LIMIT_KEYS = {
+    TIMEOUT_MAX_ACTIVE_PER_CHAT: 'TIMEOUT_MAX_ACTIVE_PER_CHAT',
+    TIMEOUT_MAX_FIRED_PER_DAY_PER_CHAT: 'TIMEOUT_MAX_FIRED_PER_DAY_PER_CHAT',
+    MAX_FILE_UPLOAD_SIZE_MB: MAX_FILE_UPLOAD_SIZE_MB_METADATA_KEY,
+    FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS: FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS_METADATA_KEY,
+    SPAWN_AGENT_MAX_DEPTH: 'SPAWN_AGENT_MAX_DEPTH',
+    SPAWN_AGENT_RATE_LIMIT_MAX: 'SPAWN_AGENT_RATE_LIMIT_MAX',
+    SPAWN_AGENT_RATE_LIMIT_WINDOW_MS: 'SPAWN_AGENT_RATE_LIMIT_WINDOW_MS',
+    LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS: 'LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS',
+};
+/**
+ * Shared metadata for all server limits exposed in the admin UI and runtime loaders.
+ *
+ * @private shared Agents Server constant
+ */
+const SERVER_LIMIT_DEFINITIONS = [
+    {
+        key: SERVER_LIMIT_KEYS.TIMEOUT_MAX_ACTIVE_PER_CHAT,
+        category: 'Timeout tools',
+        title: 'Max active timers per chat',
+        description: 'Prevents one chat thread from scheduling too many timers at once.',
+        unit: 'count',
+        defaultValue: DEFAULT_TIMEOUT_TOOL_USAGE_LIMITS.maxActivePerChat,
+        minimumValue: 1,
+        step: 1,
+        legacyMetadataKeys: [TOOL_USAGE_LIMITS_METADATA_KEY],
+    },
+    {
+        key: SERVER_LIMIT_KEYS.TIMEOUT_MAX_FIRED_PER_DAY_PER_CHAT,
+        category: 'Timeout tools',
+        title: 'Max timers fired per day per chat',
+        description: 'Limits how many scheduled wake-ups can execute inside one chat within one UTC day.',
+        unit: 'count',
+        defaultValue: DEFAULT_TIMEOUT_TOOL_USAGE_LIMITS.maxFiredPerDayPerChat,
+        minimumValue: 1,
+        step: 1,
+        legacyMetadataKeys: [TOOL_USAGE_LIMITS_METADATA_KEY],
+    },
+    {
+        key: SERVER_LIMIT_KEYS.MAX_FILE_UPLOAD_SIZE_MB,
+        category: 'Files',
+        title: 'Max file upload size',
+        description: 'Caps the size of uploaded files accepted by chat uploads and Android share-target imports.',
+        unit: 'MB',
+        defaultValue: 50,
+        minimumValue: 1,
+        step: 1,
+        legacyMetadataKeys: [MAX_FILE_UPLOAD_SIZE_MB_METADATA_KEY],
+    },
+    {
+        key: SERVER_LIMIT_KEYS.FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS,
+        category: 'Federation',
+        title: 'Federated import retry delay',
+        description: 'Wait time between retries when importing agent books from federated servers.',
+        unit: 'ms',
+        defaultValue: DEFAULT_FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS,
+        minimumValue: 0,
+        step: 100,
+        legacyMetadataKeys: [FEDERATED_AGENT_IMPORT_RETRY_DELAY_MS_METADATA_KEY],
+    },
+    {
+        key: SERVER_LIMIT_KEYS.SPAWN_AGENT_MAX_DEPTH,
+        category: 'Agent spawning',
+        title: 'Max spawn depth',
+        description: 'Restricts how many nested `spawn_agent` hops can happen inside one tool runtime context.',
+        unit: 'count',
+        defaultValue: DEFAULT_SPAWN_AGENT_MAX_DEPTH,
+        minimumValue: 1,
+        step: 1,
+        legacyMetadataKeys: [],
+    },
+    {
+        key: SERVER_LIMIT_KEYS.SPAWN_AGENT_RATE_LIMIT_MAX,
+        category: 'Agent spawning',
+        title: 'Max spawned agents per window',
+        description: 'Limits how many persistent agents one actor can create through `spawn_agent` inside one rate-limit window.',
+        unit: 'count',
+        defaultValue: DEFAULT_SPAWN_AGENT_RATE_LIMIT_MAX,
+        minimumValue: 1,
+        step: 1,
+        legacyMetadataKeys: [],
+    },
+    {
+        key: SERVER_LIMIT_KEYS.SPAWN_AGENT_RATE_LIMIT_WINDOW_MS,
+        category: 'Agent spawning',
+        title: 'Spawn rate-limit window',
+        description: 'Time window used together with the spawn quota for `spawn_agent` abuse protection.',
+        unit: 'ms',
+        defaultValue: DEFAULT_SPAWN_AGENT_RATE_LIMIT_WINDOW_MS,
+        minimumValue: 1000,
+        step: 1000,
+        legacyMetadataKeys: [],
+    },
+    {
+        key: SERVER_LIMIT_KEYS.LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS,
+        category: 'Local agent runner',
+        title: 'Max failed message attempts',
+        description: 'Stops the local coding-agent watcher from retrying the same queued chat message forever.',
+        unit: 'count',
+        defaultValue: DEFAULT_LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS,
+        minimumValue: 1,
+        step: 1,
+        legacyMetadataKeys: [],
+    },
+];
+/**
+ * Fast lookup map used by server-limit validators and UI helpers.
+ *
+ * @private shared Agents Server constant
+ */
+new Map(SERVER_LIMIT_DEFINITIONS.map((definition) => [definition.key, definition]));
+/**
+ * Fully normalized default values keyed by dedicated server-limit ids.
+ *
+ * @private shared Agents Server constant
+ */
+const defaultServerLimitValues = {};
+for (const definition of SERVER_LIMIT_DEFINITIONS) {
+    defaultServerLimitValues[definition.key] = definition.defaultValue;
+}
+/**
+ * Default values used whenever a server-limit row has not been persisted yet.
+ *
+ * @private shared Agents Server constant
+ */
+Object.freeze(defaultServerLimitValues);
+/**
+ * Deprecated metadata keys that now mirror dedicated server-limit rows for backward compatibility.
+ *
+ * @private shared Agents Server constant
+ */
+Array.from(new Set(SERVER_LIMIT_DEFINITIONS.flatMap((definition) => definition.legacyMetadataKeys)));
+
 /**
  * Local worker-pump delay while the Agents Server foreground process stays active.
  *
@@ -36187,6 +37165,18 @@ const USER_CHAT_JOB_WORKER_REPEATED_ERROR_LOG_INTERVAL = 10;
  * @private internal constant of `ptbk agents-server`
  */
 const USER_CHAT_JOB_WORKER_ERROR_BODY_MAX_LENGTH = 2000;
+/**
+ * Delay between foreground CLI attempts to load internal Agents Server limits during startup.
+ *
+ * @private internal constant of `ptbk agents-server`
+ */
+const INTERNAL_SERVER_LIMITS_RETRY_DELAY_MS = 1000;
+/**
+ * Maximum time spent waiting for the internal limits route before startup fails.
+ *
+ * @private internal constant of `ptbk agents-server`
+ */
+const INTERNAL_SERVER_LIMITS_STARTUP_TIMEOUT_MS = 60000;
 /**
  * HTTP status used by an idle internal worker tick with no job to process.
  *
@@ -36293,6 +37283,12 @@ async function startAgentsServer(options) {
             logStreams,
             state,
         });
+        const localAgentRunnerLimits = await waitForLocalAgentRunnerLimits({
+            port: options.port,
+            environment: runtimeChildEnvironment,
+            logStreams,
+            state,
+        });
         stopUserChatJobWorkerPump = startUserChatJobWorkerPump({
             port: options.port,
             environment: runtimeChildEnvironment,
@@ -36300,7 +37296,7 @@ async function startAgentsServer(options) {
             state,
         });
         await withCurrentWorkingDirectory(runtimePaths.agentRootPath, async () => {
-            await runMultipleAgentMessages(createLocalAgentRunOptions(options), {
+            await runMultipleAgentMessages(createLocalAgentRunOptions(options, localAgentRunnerLimits), {
                 shouldContinue: () => state.isContinuing,
                 watchErrorLogDirectoryPath: runtimePaths.logDirectoryPath,
                 onUiInitialized: (uiHandle) => {
@@ -36429,7 +37425,7 @@ function createAgentsServerChildEnvironment(port, agentRootPath) {
 /**
  * Creates local no-git agent runner options for folders managed by the Agents Server database.
  */
-function createLocalAgentRunOptions(options) {
+function createLocalAgentRunOptions(options, localAgentRunnerLimits) {
     return {
         agentName: options.agentName,
         model: options.model,
@@ -36442,8 +37438,67 @@ function createLocalAgentRunOptions(options) {
         autoPush: false,
         autoPull: false,
         autoClone: false,
+        maxMessageProcessingFailures: localAgentRunnerLimits.maxFailedAttempts,
+    };
+}
+/**
+ * Waits until the internal Next route can return current local runner limits.
+ */
+async function waitForLocalAgentRunnerLimits(options) {
+    const startedAt = Date.now();
+    let lastError;
+    while (options.state.isContinuing && Date.now() - startedAt < INTERNAL_SERVER_LIMITS_STARTUP_TIMEOUT_MS) {
+        try {
+            const limits = await fetchLocalAgentRunnerLimits(options);
+            logRunnerEvent(options.logStreams.runner, `Local agent runner max failed attempts: ${limits.maxFailedAttempts}.`);
+            return limits;
+        }
+        catch (error) {
+            lastError = error;
+            await wait$2(INTERNAL_SERVER_LIMITS_RETRY_DELAY_MS);
+        }
+    }
+    if (!options.state.isContinuing) {
+        return {
+            maxFailedAttempts: DEFAULT_LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS,
+        };
+    }
+    throw new NotAllowed(spaceTrim$1(`
+            Failed to load local agent runner limits from the Agents Server.
+
+            ${lastError instanceof Error ? lastError.message : String(lastError)}
+        `));
+}
+/**
+ * Loads local runner limits through the token-protected internal Agents Server route.
+ */
+async function fetchLocalAgentRunnerLimits(options) {
+    const response = await fetch(`http://localhost:${options.port}/api/internal/agent-runner-limits`, {
+        method: 'GET',
+        cache: 'no-store',
+        headers: {
+            'x-user-chat-worker-token': options.environment.PTBK_AGENTS_SERVER_USER_CHAT_WORKER_TOKEN,
+        },
+    });
+    if (!response.ok) {
+        const details = await readUserChatJobWorkerErrorDetails(response);
+        throw new Error(createInternalRouteErrorMessage('agent runner limits', response, details));
+    }
+    const payload = (await response.json());
+    return {
+        maxFailedAttempts: normalizeLocalAgentRunnerMaxFailedAttempts(payload.maxFailedAttempts),
     };
 }
+/**
+ * Normalizes the local runner retry cap returned by the internal server route.
+ */
+function normalizeLocalAgentRunnerMaxFailedAttempts(rawValue) {
+    const parsedValue = Number(rawValue);
+    if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
+        return DEFAULT_LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS;
+    }
+    return Math.floor(parsedValue);
+}
 /**
  * Starts periodic internal worker calls that queue and reconcile local message-folder jobs.
  */
@@ -36552,12 +37607,18 @@ function parseUserChatJobWorkerErrorMessage(body) {
  * Builds the foreground worker failure message from HTTP status and route details.
  */
 function createUserChatJobWorkerErrorMessage(response, details) {
+    return createInternalRouteErrorMessage('user chat worker', response, details);
+}
+/**
+ * Builds a foreground failure message for one internal Agents Server route.
+ */
+function createInternalRouteErrorMessage(routeLabel, response, details) {
     const statusText = response.statusText ? ` ${response.statusText}` : '';
     const statusMessage = `${response.status}${statusText}`;
     if (!details) {
-        return `Internal user chat worker returned ${statusMessage}.`;
+        return `Internal ${routeLabel} route returned ${statusMessage}.`;
     }
-    return `Internal user chat worker returned ${statusMessage}: ${details}`;
+    return `Internal ${routeLabel} route returned ${statusMessage}: ${details}`;
 }
 /**
  * Keeps foreground worker diagnostics bounded when a route returns a large payload.
@@ -36627,6 +37688,12 @@ function stopChildProcess(commandProcess) {
     }
     commandProcess.kill();
 }
+/**
+ * Waits for the given delay.
+ */
+async function wait$2(delayMs) {
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
 // Note: [🟡] Code for CLI runtime [startAgentsServer](src/cli/cli-commands/agents-server/startAgentsServer.ts) should never be published outside of `@promptbook/cli`
 
 /**
@@ -61284,14 +62351,18 @@ const AGENT_IDLE_AUTO_PULL_INTERVAL_MS = 30000;
  * Watches the queued message directory and answers messages one by one.
  */
 async function runAgentMessages(options, controls = {}) {
-    var _a;
+    var _a, _b;
     validateAgentRunOptions(options);
     validateAgentWatchOptions('ptbk agent-folder run-agent', options);
     const projectPath = process.cwd();
     let autoPullTimestamp = options.autoPull ? Date.now() : undefined;
     const shouldContinue = controls.shouldContinue || (() => just(true));
+    const queuePollIntervalMs = (_a = controls.queuePollIntervalMs) !== null && _a !== void 0 ? _a : AGENT_QUEUE_POLL_INTERVAL_MS;
     let isWatchSessionInitialized = false;
     let uiHandle;
+    const messageFailureTracker = new AgentMessageFailureTracker({
+        maxMessageProcessingFailures: options.maxMessageProcessingFailures,
+    });
     while (shouldContinue()) {
         try {
             if (!isWatchSessionInitialized) {
@@ -61303,8 +62374,9 @@ async function runAgentMessages(options, controls = {}) {
                 }
             }
             const result = await tickAgentMessages(options, { isQuietWhenIdle: true, uiHandle });
-            autoPullTimestamp = (_a = result.autoPullTimestamp) !== null && _a !== void 0 ? _a : autoPullTimestamp;
+            autoPullTimestamp = (_b = result.autoPullTimestamp) !== null && _b !== void 0 ? _b : autoPullTimestamp;
             if (result.isMessageProcessed) {
+                messageFailureTracker.clearMessageFailure(projectPath, result.queuedMessage);
                 continue;
             }
             autoPullTimestamp = await waitForQueuedAgentMessage({
@@ -61313,6 +62385,7 @@ async function runAgentMessages(options, controls = {}) {
                 autoPullTimestamp,
                 uiHandle,
                 shouldContinue,
+                queuePollIntervalMs,
             });
         }
         catch (error) {
@@ -61321,7 +62394,8 @@ async function runAgentMessages(options, controls = {}) {
                 logDirectoryPath: projectPath,
                 error,
             });
-            await wait(AGENT_QUEUE_POLL_INTERVAL_MS);
+            await messageFailureTracker.recordFailure(error);
+            await wait(queuePollIntervalMs);
         }
     }
 }
@@ -61329,14 +62403,14 @@ async function runAgentMessages(options, controls = {}) {
  * Polls until at least one queued `.book` message is available.
  */
 async function waitForQueuedAgentMessage(options) {
-    const { projectPath, options: runOptions, uiHandle, shouldContinue } = options;
+    const { projectPath, options: runOptions, uiHandle, shouldContinue, queuePollIntervalMs } = options;
     let { autoPullTimestamp } = options;
     let queueSnapshot = await loadAgentMessageQueueSnapshot(projectPath);
     if (uiHandle) {
         updateAgentRunUiForWatching(uiHandle, queueSnapshot);
     }
     while (shouldContinue()) {
-        await wait(AGENT_QUEUE_POLL_INTERVAL_MS);
+        await wait(queuePollIntervalMs);
         queueSnapshot = await loadAgentMessageQueueSnapshot(projectPath);
         if (queueSnapshot.queuedMessages.length > 0) {
             return autoPullTimestamp;