@promptbook/cli 0.113.0-5 → 0.113.0-8

package/esm/scripts/find-refactor-candidates/find-refactor-candidates.d.ts

@@ -15,4 +15,11 @@ export type FindRefactorCandidatesOptions = {
      * Aggressiveness level used to score candidate files.
      */
     readonly level?: RefactorCandidateLevel;
+    /**
+     * Maximum number of refactor prompts to create in this run.
+     *
+     * When more candidates are found than this limit, only the most important ones (by severity)
+     * are turned into prompts. When omitted, a prompt is created for every candidate.
+     */
+    readonly limit?: number;
 };

package/esm/scripts/find-refactor-candidates/selectMostImportantRefactorCandidates.d.ts

@@ -0,0 +1,12 @@
+import type { RefactorCandidate } from './RefactorCandidate';
+/**
+ * Keeps at most `limit` refactor candidates, preferring the most important ones.
+ *
+ * When there are more candidates than `limit`, only the highest-severity candidates are kept
+ * (ties broken by relative path for determinism). When `limit` is `undefined` or there are fewer
+ * candidates than the limit, every candidate is returned. The original input order is preserved
+ * among the kept candidates, so `limit` acts purely as a filter and never reorders prompts.
+ *
+ * @private function of findRefactorCandidates
+ */
+export declare function selectMostImportantRefactorCandidates(candidates: ReadonlyArray<RefactorCandidate>, limit: number | undefined): ReadonlyArray<RefactorCandidate>;

package/esm/src/book-components/Chat/Chat/insertDictationChunk.d.ts

@@ -8,7 +8,7 @@ export declare function insertDictationChunk(params: {
     readonly dictatedText: string;
     readonly selectionStart: number;
     readonly selectionEnd: number;
-    readonly shouldReplaceSelection: boolean;
+    readonly isReplacingSelection: boolean;
 }): {
     nextValue: string;
     start: number;

package/esm/src/book-components/Chat/Chat/insertDictationChunk.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/book-components/Chat/Chat/learnDictationDictionary.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/book-components/Chat/Chat/refineFinalDictationChunk.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/cli/cli-commands/common/createPositiveIntegerOptionParser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a Commander argument parser that accepts only positive integers.
+ *
+ * The returned parser is meant to be passed as the coercion callback of `command.option(...)`.
+ * It throws a branded `NotAllowed` error with a clear message referencing the given option name
+ * when the provided value is not a positive integer.
+ *
+ * @private internal utility of `promptbookCli`
+ */
+export declare function createPositiveIntegerOptionParser(optionName: string): (value: string) => number;

package/esm/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.113.0-4`).
+ * It follows semantic versioning (e.g., `0.113.0-5`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/cli",
-    "version": "0.113.0-5",
+    "version": "0.113.0-8",
     "description": "Promptbook: Create persistent AI agents that turn your company's scattered knowledge into action",
     "private": false,
     "sideEffects": false,

package/src/avatars/avatarAnimationScheduler.ts

@@ -133,7 +133,8 @@ function ensureAvatarAnimationLoop(): void {
         // Run the most stale listeners first so each avatar keeps its target FPS even when
         // total work exceeds the per-frame budget.
         dueListenerEntries.sort(
-            (firstListenerEntry, secondListenerEntry) => firstListenerEntry.lastRunAtMs - secondListenerEntry.lastRunAtMs,
+            (firstListenerEntry, secondListenerEntry) =>
+                firstListenerEntry.lastRunAtMs - secondListenerEntry.lastRunAtMs,
         );
 
         const listenersToRunCount = Math.min(dueListenerEntries.length, MAX_AVATAR_LISTENERS_PER_FRAME);

package/src/avatars/visuals/octopus3d3AvatarVisual.ts

@@ -502,12 +502,16 @@ function resolveVisibleContinuousOctopusPatches(
     }
 
     for (let longitudeIndex = 0; longitudeIndex < longitudePatchCount; longitudeIndex++) {
-        const patchCenterLongitude = (longitudeBoundaries[longitudeIndex]! + longitudeBoundaries[longitudeIndex + 1]!) / 2;
+        const patchCenterLongitude =
+            (longitudeBoundaries[longitudeIndex]! + longitudeBoundaries[longitudeIndex + 1]!) / 2;
         cachedTentacleInfluencesByPatchCenterLongitude[longitudeIndex] = resolveContinuousTentacleInfluence(
             options,
             patchCenterLongitude,
         );
-        cachedLobeWavesByPatchCenterLongitude[longitudeIndex] = resolveContinuousLobeWave(options, patchCenterLongitude);
+        cachedLobeWavesByPatchCenterLongitude[longitudeIndex] = resolveContinuousLobeWave(
+            options,
+            patchCenterLongitude,
+        );
         cachedCosByPatchCenterLongitude[longitudeIndex] = Math.max(0, Math.cos(patchCenterLongitude));
     }
 

package/src/avatars/visuals/octopus3d4AvatarVisual.ts

@@ -193,8 +193,14 @@ export const octopus3d4AvatarVisual: AvatarVisualDefinition = {
     isAnimated: true,
     supportsPointerTracking: true,
     render({ context, size, palette, createRandom, timeMs, interaction }) {
-        const { morphologyProfile, animationPhase, leftEyePhaseOffset, rightEyePhaseOffset, tentacleProfiles, skinSpots } =
-            getOctopus3d4StableState(createRandom);
+        const {
+            morphologyProfile,
+            animationPhase,
+            leftEyePhaseOffset,
+            rightEyePhaseOffset,
+            tentacleProfiles,
+            skinSpots,
+        } = getOctopus3d4StableState(createRandom);
         const sceneCenterX = size * 0.5;
         const sceneCenterY = size * 0.535;
         const bob = Math.sin(timeMs / 980 + animationPhase) * size * 0.013;
@@ -568,7 +574,8 @@ function resolveVisibleBlobbyContinuousPatches(
     }
 
     for (let longitudeIndex = 0; longitudeIndex < longitudePatchCount; longitudeIndex++) {
-        const patchCenterLongitude = (longitudeBoundaries[longitudeIndex]! + longitudeBoundaries[longitudeIndex + 1]!) / 2;
+        const patchCenterLongitude =
+            (longitudeBoundaries[longitudeIndex]! + longitudeBoundaries[longitudeIndex + 1]!) / 2;
         cachedTentacleInfluencesByPatchCenterLongitude[longitudeIndex] = resolveBlobbyTentacleInfluence(
             options,
             patchCenterLongitude,
@@ -702,8 +709,7 @@ function sampleBlobbyContinuousSurfacePointWithLongitudeCache(
     const lowerBlend = smoothStep(0.34, 1, verticalProgress);
     const tipBlend = smoothStep(0.66, 1, verticalProgress);
     const centerPull = resolveSignedAngularDistance(longitude, tentacleInfluence.centerLongitude);
-    const effectiveLongitude =
-        longitude + centerPull * lowerBlend * tentacleInfluence.core * (0.26 + tipBlend * 0.22);
+    const effectiveLongitude = longitude + centerPull * lowerBlend * tentacleInfluence.core * (0.26 + tipBlend * 0.22);
     const mantleRipple =
         Math.sin(
             longitude * morphologyProfile.body.lobeCount +
@@ -742,10 +748,7 @@ function sampleBlobbyContinuousSurfacePointWithLongitudeCache(
         lowerBlend * tentacleInfluence.core * (0.12 + tentacleInfluence.depthScale * 0.07) -
         Math.max(0, -Math.cos(effectiveLongitude)) * 0.05;
     const tentacleTubeRadius =
-        lowerBlend *
-        tentacleInfluence.core *
-        (0.12 + tipBlend * 0.07 + tentacleInfluence.widthScale * 0.028) *
-        radiusX;
+        lowerBlend * tentacleInfluence.core * (0.12 + tipBlend * 0.07 + tentacleInfluence.widthScale * 0.028) * radiusX;
     const planarRadiusX = cosineLatitude * radiusX * horizontalScale + tentacleTubeRadius;
     const planarRadiusZ = cosineLatitude * radiusZ * depthScale + tentacleTubeRadius * 0.74;
     const lowerDrop =
@@ -759,10 +762,7 @@ function sampleBlobbyContinuousSurfacePointWithLongitudeCache(
     const combinedTentacleSway = (primaryTentacleWave + secondaryTentacleWave) * radiusX * (0.06 + tipBlend * 0.06);
 
     return {
-        x:
-            Math.sin(effectiveLongitude) * planarRadiusX +
-            combinedTentacleSway +
-            tentacleCurl * radiusX * 0.18,
+        x: Math.sin(effectiveLongitude) * planarRadiusX + combinedTentacleSway + tentacleCurl * radiusX * 0.18,
         y:
             Math.sin(latitude) * radiusY * (1 + upperBlend * 0.14) -
             upperBlend * radiusY * 0.12 +
@@ -911,11 +911,7 @@ function drawBlobbyContinuousSurfacePatch(
     drawProjectedQuad(context, surfacePatch.corners, surfacePatch.fillStyle);
 
     if (surfacePatch.lightIntensity > 0) {
-        drawProjectedQuad(
-            context,
-            surfacePatch.corners,
-            `rgba(255, 255, 255, ${0.2 * surfacePatch.lightIntensity})`,
-        );
+        drawProjectedQuad(context, surfacePatch.corners, `rgba(255, 255, 255, ${0.2 * surfacePatch.lightIntensity})`);
     } else if (surfacePatch.lightIntensity < 0) {
         drawProjectedQuad(
             context,

package/src/book-components/Chat/Chat/insertDictationChunk.ts

@@ -8,11 +8,11 @@ export function insertDictationChunk(params: {
     readonly dictatedText: string;
     readonly selectionStart: number;
     readonly selectionEnd: number;
-    readonly shouldReplaceSelection: boolean;
+    readonly isReplacingSelection: boolean;
 }): { nextValue: string; start: number; caret: number } {
-    const { currentValue, dictatedText, selectionStart, selectionEnd, shouldReplaceSelection } = params;
+    const { currentValue, dictatedText, selectionStart, selectionEnd, isReplacingSelection } = params;
     const replaceStart = selectionStart;
-    const replaceEnd = shouldReplaceSelection ? selectionEnd : selectionStart;
+    const replaceEnd = isReplacingSelection ? selectionEnd : selectionStart;
     const prefix = currentValue.slice(0, replaceStart);
     const suffix = currentValue.slice(replaceEnd);
     const previousCharacter = prefix.slice(-1);

package/src/book-components/Chat/Chat/learnDictationDictionary.ts

@@ -30,7 +30,7 @@ export function learnDictationDictionary(
                 continue;
             }
 
-            if (previousWord.toLowerCase() !== correctedWord.toLowerCase()) {
+            if (previousWord !== correctedWord) {
                 nextDictionary[previousWord.toLowerCase()] = correctedWord;
             }
         }

package/src/book-components/Chat/Chat/useChatInputAreaDictation.ts

@@ -38,6 +38,17 @@ type DictationChunk = {
     readonly start: number;
 };
 
+/**
+ * Stable insertion range captured when the user starts dictation.
+ *
+ * @private function of `useChatInputAreaDictation`
+ */
+type DictationInsertionSelection = {
+    readonly selectionStart: number;
+    readonly selectionEnd: number;
+    readonly isReplacingSelection: boolean;
+};
+
 /**
  * Stable dictation error shape consumed by the correction panel UI.
  *
@@ -88,7 +99,7 @@ type UseChatInputAreaDictationFinalResultHandlerProps = {
     readonly applyMessageContent: (nextContent: string) => void;
     readonly dictationSettings: DictationRefinementSettings;
     readonly dictationDictionary: ReturnType<typeof useChatInputAreaDictationPersistence>['dictationDictionary'];
-    readonly replaceSelectionOnNextFinalRef: MutableRefObject<boolean>;
+    readonly dictationInsertionSelectionRef: MutableRefObject<DictationInsertionSelection | null>;
     readonly focusTextareaSelection: (selectionStart: number, selectionEnd: number) => void;
     readonly state: UseChatInputAreaDictationState;
 };
@@ -126,7 +137,7 @@ type UseChatInputAreaDictationVoiceInputControlsProps = {
     readonly resolvedSpeechRecognitionLanguage: string;
     readonly whisperMode: boolean;
     readonly pendingStopFallbackRef: MutableRefObject<ReturnType<typeof setTimeout> | null>;
-    readonly replaceSelectionOnNextFinalRef: MutableRefObject<boolean>;
+    readonly dictationInsertionSelectionRef: MutableRefObject<DictationInsertionSelection | null>;
     readonly clearPendingStopFallback: () => void;
     readonly state: Pick<
         UseChatInputAreaDictationState,
@@ -144,6 +155,7 @@ type UseChatInputAreaDictationCorrectionHandlersProps = {
     readonly dictationLastFinalChunk: string;
     readonly dictationEditableChunk: string;
     readonly dictationDictionary: ReturnType<typeof useChatInputAreaDictationPersistence>['dictationDictionary'];
+    readonly dictationInsertionSelectionRef: MutableRefObject<DictationInsertionSelection | null>;
     readonly messageContentRef: MutableRefObject<string>;
     readonly applyMessageContent: (nextContent: string) => void;
     readonly focusTextareaSelection: (selectionStart: number, selectionEnd: number) => void;
@@ -235,21 +247,96 @@ function clearPendingStopFallbackTimeout(
 }
 
 /**
- * Captures whether the next finalized chunk should replace the current selection.
+ * Captures where the next finalized chunk should be inserted.
  *
  * @private function of `useChatInputAreaDictation`
  */
-function captureSelectionReplacementIntent(
+function captureDictationInsertionSelection(
     textareaRef: MutableRefObject<HTMLTextAreaElement | null>,
-    replaceSelectionOnNextFinalRef: MutableRefObject<boolean>,
+    dictationInsertionSelectionRef: MutableRefObject<DictationInsertionSelection | null>,
 ): void {
     const textarea = textareaRef.current;
     if (!textarea) {
         return;
     }
 
-    const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, 0);
-    replaceSelectionOnNextFinalRef.current = selectionStart !== selectionEnd;
+    const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, textarea.value.length);
+    dictationInsertionSelectionRef.current = {
+        selectionStart,
+        selectionEnd,
+        isReplacingSelection: selectionStart !== selectionEnd,
+    };
+}
+
+/**
+ * Resolves the insertion range for one finalized dictation chunk.
+ *
+ * @private function of `useChatInputAreaDictation`
+ */
+function resolveDictationInsertionSelection(
+    textareaElement: HTMLTextAreaElement,
+    messageContentLength: number,
+    dictationInsertionSelection: DictationInsertionSelection | null,
+): DictationInsertionSelection {
+    if (dictationInsertionSelection) {
+        return dictationInsertionSelection;
+    }
+
+    const { selectionStart, selectionEnd } = resolveTextareaSelection(textareaElement, messageContentLength);
+
+    return {
+        selectionStart,
+        selectionEnd,
+        isReplacingSelection: selectionStart !== selectionEnd,
+    };
+}
+
+/**
+ * Removes one tracked dictated chunk from the current composer value.
+ *
+ * @private function of `useChatInputAreaDictation`
+ */
+function removeTrackedDictationChunk(currentValue: string, chunk: DictationChunk): string {
+    const trackedText = currentValue.slice(chunk.start, chunk.start + chunk.finalText.length);
+
+    if (trackedText === chunk.finalText) {
+        return `${currentValue.slice(0, chunk.start)}${currentValue.slice(chunk.start + chunk.finalText.length)}`;
+    }
+
+    return replaceLastOccurrence(currentValue, chunk.finalText, '');
+}
+
+/**
+ * Replaces one tracked dictated chunk inside the current composer value.
+ *
+ * @private function of `useChatInputAreaDictation`
+ */
+function replaceTrackedDictationChunk(currentValue: string, chunk: DictationChunk, correctedChunk: string): string {
+    const trackedText = currentValue.slice(chunk.start, chunk.start + chunk.finalText.length);
+
+    if (trackedText === chunk.finalText) {
+        return `${currentValue.slice(0, chunk.start)}${correctedChunk}${currentValue.slice(
+            chunk.start + chunk.finalText.length,
+        )}`;
+    }
+
+    return replaceLastOccurrence(currentValue, chunk.finalText, correctedChunk);
+}
+
+/**
+ * Stores the next append position after a programmatic dictation edit.
+ *
+ * @private function of `useChatInputAreaDictation`
+ */
+function updateDictationInsertionCaret(
+    dictationInsertionSelectionRef: MutableRefObject<DictationInsertionSelection | null>,
+    caret: number,
+): void {
+    dictationInsertionSelectionRef.current = {
+        selectionStart: caret,
+        selectionEnd: caret,
+        isReplacingSelection: false,
+    };
 }
 
 /**
@@ -376,7 +463,7 @@ function useChatInputAreaDictationFinalResultHandler({
     applyMessageContent,
     dictationSettings,
     dictationDictionary,
-    replaceSelectionOnNextFinalRef,
+    dictationInsertionSelectionRef,
     focusTextareaSelection,
     state,
 }: UseChatInputAreaDictationFinalResultHandlerProps) {
@@ -403,16 +490,20 @@ function useChatInputAreaDictationFinalResultHandler({
                 return;
             }
 
-            const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, previousMessageContent.length);
+            const { selectionStart, selectionEnd, isReplacingSelection } = resolveDictationInsertionSelection(
+                textarea,
+                previousMessageContent.length,
+                dictationInsertionSelectionRef.current,
+            );
             const insertion = insertDictationChunk({
                 currentValue: previousMessageContent,
                 dictatedText: refinedText,
                 selectionStart,
                 selectionEnd,
-                shouldReplaceSelection: replaceSelectionOnNextFinalRef.current,
+                isReplacingSelection,
             });
 
-            replaceSelectionOnNextFinalRef.current = false;
+            updateDictationInsertionCaret(dictationInsertionSelectionRef, insertion.caret);
             setDictationInterimText('');
             setDictationError(null);
             setDictationUiState('listening');
@@ -433,10 +524,10 @@ function useChatInputAreaDictationFinalResultHandler({
         [
             applyMessageContent,
             dictationDictionary,
+            dictationInsertionSelectionRef,
             dictationSettings,
             focusTextareaSelection,
             messageContentRef,
-            replaceSelectionOnNextFinalRef,
             setDictationChunks,
             setDictationEditableChunk,
             setDictationError,
@@ -491,7 +582,9 @@ function useChatInputAreaDictationSpeechRecognitionEventHandler({
                     return;
                 case 'STOP':
                     clearPendingStopFallback();
-                    setDictationUiState((currentState) => (currentState === 'disabled' ? currentState : 'idle'));
+                    setDictationUiState((currentState) =>
+                        currentState === 'disabled' || currentState === 'error' ? currentState : 'idle',
+                    );
                     setDictationInterimText('');
                     return;
             }
@@ -549,7 +642,7 @@ function useChatInputAreaDictationVoiceInputControls({
     resolvedSpeechRecognitionLanguage,
     whisperMode,
     pendingStopFallbackRef,
-    replaceSelectionOnNextFinalRef,
+    dictationInsertionSelectionRef,
     clearPendingStopFallback,
     state,
 }: UseChatInputAreaDictationVoiceInputControlsProps) {
@@ -560,7 +653,7 @@ function useChatInputAreaDictationVoiceInputControls({
             return;
         }
 
-        captureSelectionReplacementIntent(textareaRef, replaceSelectionOnNextFinalRef);
+        captureDictationInsertionSelection(textareaRef, dictationInsertionSelectionRef);
         setDictationError(null);
         setDictationInterimText('');
         setDictationUiState('listening');
@@ -570,7 +663,7 @@ function useChatInputAreaDictationVoiceInputControls({
             whisperMode,
         });
     }, [
-        replaceSelectionOnNextFinalRef,
+        dictationInsertionSelectionRef,
         resolvedSpeechRecognitionLanguage,
         setDictationError,
         setDictationInterimText,
@@ -635,6 +728,7 @@ function useChatInputAreaDictationCorrectionHandlers({
     dictationLastFinalChunk,
     dictationEditableChunk,
     dictationDictionary,
+    dictationInsertionSelectionRef,
     messageContentRef,
     applyMessageContent,
     focusTextareaSelection,
@@ -651,17 +745,23 @@ function useChatInputAreaDictationCorrectionHandlers({
             return;
         }
 
+        const nextMessageContent = removeTrackedDictationChunk(messageContentRef.current, lastChunk);
+        const nextCaret = Math.min(lastChunk.start, nextMessageContent.length);
+
         setDictationChunks(previousChunks);
-        applyMessageContent(lastChunk.beforeValue);
+        applyMessageContent(nextMessageContent);
 
         const previousFinalChunk = previousChunks[previousChunks.length - 1]?.finalText || '';
         setDictationLastFinalChunk(previousFinalChunk);
         setDictationEditableChunk(previousFinalChunk);
-        focusTextareaSelection(lastChunk.start, lastChunk.start);
+        updateDictationInsertionCaret(dictationInsertionSelectionRef, nextCaret);
+        focusTextareaSelection(nextCaret, nextCaret);
     }, [
         applyMessageContent,
+        dictationInsertionSelectionRef,
         dictationChunks,
         focusTextareaSelection,
+        messageContentRef,
         setDictationChunks,
         setDictationEditableChunk,
         setDictationLastFinalChunk,
@@ -673,21 +773,27 @@ function useChatInputAreaDictationCorrectionHandlers({
             return;
         }
 
-        const nextMessageContent = replaceLastOccurrence(
-            messageContentRef.current,
-            dictationLastFinalChunk,
-            correctedChunk,
-        );
+        const lastChunk = dictationChunks[dictationChunks.length - 1];
+        const nextMessageContent = lastChunk
+            ? replaceTrackedDictationChunk(messageContentRef.current, lastChunk, correctedChunk)
+            : replaceLastOccurrence(messageContentRef.current, dictationLastFinalChunk, correctedChunk);
+        const correctionStart = lastChunk?.start ?? nextMessageContent.length;
+        const correctionCaret = Math.min(correctionStart + correctedChunk.length, nextMessageContent.length);
 
         applyMessageContent(nextMessageContent);
         setDictationLastFinalChunk(correctedChunk);
         setDictationChunks((previousChunks) => replaceLastDictationChunk(previousChunks, correctedChunk));
         setDictationDictionary(learnDictationDictionary(dictationLastFinalChunk, correctedChunk, dictationDictionary));
+        updateDictationInsertionCaret(dictationInsertionSelectionRef, correctionCaret);
+        focusTextareaSelection(correctionCaret, correctionCaret);
     }, [
         applyMessageContent,
         dictationDictionary,
         dictationEditableChunk,
+        dictationChunks,
+        dictationInsertionSelectionRef,
         dictationLastFinalChunk,
+        focusTextareaSelection,
         messageContentRef,
         setDictationChunks,
         setDictationDictionary,
@@ -713,7 +819,7 @@ export function useChatInputAreaDictation({
     applyMessageContent,
 }: UseChatInputAreaDictationProps) {
     const pendingStopFallbackRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-    const replaceSelectionOnNextFinalRef = useRef(false);
+    const dictationInsertionSelectionRef = useRef<DictationInsertionSelection | null>(null);
     const [dictationUiState, setDictationUiState] = useState<DictationUiState>('idle');
     const [dictationInterimText, setDictationInterimText] = useState('');
     const [dictationError, setDictationError] = useState<DictationError | null>(null);
@@ -753,7 +859,7 @@ export function useChatInputAreaDictation({
         applyMessageContent,
         dictationSettings,
         dictationDictionary,
-        replaceSelectionOnNextFinalRef,
+        dictationInsertionSelectionRef,
         focusTextareaSelection,
         state: dictationState,
     });
@@ -775,7 +881,7 @@ export function useChatInputAreaDictation({
         resolvedSpeechRecognitionLanguage,
         whisperMode: dictationSettings.whisperMode,
         pendingStopFallbackRef,
-        replaceSelectionOnNextFinalRef,
+        dictationInsertionSelectionRef,
         clearPendingStopFallback,
         state: {
             dictationUiState,
@@ -789,6 +895,7 @@ export function useChatInputAreaDictation({
         dictationLastFinalChunk,
         dictationEditableChunk,
         dictationDictionary,
+        dictationInsertionSelectionRef,
         messageContentRef,
         applyMessageContent,
         focusTextareaSelection,

package/src/cli/cli-commands/agents-server/buildAgentsServer.ts

@@ -739,7 +739,9 @@ function isNextBuildTerminationRetryable(exitStatus: NextBuildExitStatus): boole
  * Creates one visible retry message for a killed Next.js build attempt.
  */
 function createNextBuildRetryMessage(exitStatus: NextBuildExitStatus, nextAttempt: number): string {
-    return `\nAgents Server Next build was terminated by ${describeNextBuildExitStatus(exitStatus)}. Retrying attempt ${nextAttempt}/${AGENTS_SERVER_BUILD_MAX_ATTEMPTS}.\n`;
+    return `\nAgents Server Next build was terminated by ${describeNextBuildExitStatus(
+        exitStatus,
+    )}. Retrying attempt ${nextAttempt}/${AGENTS_SERVER_BUILD_MAX_ATTEMPTS}.\n`;
 }
 
 /**

package/src/cli/cli-commands/coder/boilerplateTemplates.ts

@@ -120,26 +120,26 @@ const DEFAULT_CODER_PROMPT_TEMPLATE_DEFINITIONS = [
         id: 'common',
         relativeFilePath: join(PROMPTS_TEMPLATES_DIRECTORY_PATH, 'common.md'),
         slugPrefix: null,
-        content: buildCoderPromptTemplateContent([
-            '-   @@@',
-            "-   Keep in mind the DRY _(don't repeat yourself)_ principle.",
-            '-   Do a proper analysis of the current functionality before you start implementing.',
-            '-   Add the changes into the [changelog](changelog/_current-preversion.md)',
-        ]),
+        content: spaceTrim(`
+            -   @@@
+            -   Keep in mind the DRY _(don't repeat yourself)_ principle.
+            -   Do a proper analysis of the current functionality before you start implementing.
+            -   Add the changes into the [changelog](changelog/_current-preversion.md)
+        `),
         isDefaultProjectTemplate: true,
     },
     {
         id: 'agents-server',
         relativeFilePath: join(PROMPTS_TEMPLATES_DIRECTORY_PATH, 'agents-server.md'),
         slugPrefix: 'agents-server',
-        content: buildCoderPromptTemplateContent([
-            '-   @@@',
-            "-   Keep in mind the DRY _(don't repeat yourself)_ principle.",
-            '-   Do a proper analysis of the current functionality before you start implementing.',
-            '-   You are working with the [Agents Server](apps/agents-server)',
-            '-   If you need to do the database migration, do it',
-            '-   Add the changes into the [changelog](changelog/_current-preversion.md)',
-        ]),
+        content: spaceTrim(`
+            -   @@@
+            -   Keep in mind the DRY _(don't repeat yourself)_ principle.
+            -   Do a proper analysis of the current functionality before you start implementing.
+            -   You are working with the [Agents Server](apps/agents-server)
+            -   If you need to do the database migration, do it
+            -   Add the changes into the [changelog](changelog/_current-preversion.md)
+        `),
         isDefaultProjectTemplate: false,
     },
 ] as const satisfies ReadonlyArray<CoderPromptTemplateDefinition>;
@@ -288,13 +288,6 @@ function getDefaultCoderPromptTemplateDefinitionOrUndefined(
     return DEFAULT_CODER_PROMPT_TEMPLATE_DEFINITIONS.find((definition) => definition.id === template);
 }
 
-/**
- * Builds stable markdown content for one coder prompt template without indentation drift.
- */
-function buildCoderPromptTemplateContent(lines: ReadonlyArray<string>): string {
-    return lines.join('\n');
-}
-
 /**
  * Creates a fully resolved template payload from one built-in definition.
  */

package/src/cli/cli-commands/coder/find-refactor-candidates.ts

@@ -12,6 +12,7 @@ import {
 } from '../../../../scripts/find-refactor-candidates/RefactorCandidateLevel';
 import { assertsError } from '../../../errors/assertsError';
 import type { $side_effect } from '../../../utils/organization/$side_effect';
+import { createPositiveIntegerOptionParser } from '../common/createPositiveIntegerOptionParser';
 import { handleActionErrors } from '../common/handleActionErrors';
 
 /**
@@ -44,11 +45,17 @@ export function $initializeCoderFindRefactorCandidatesCommand(program: Program):
             .choices([...REFACTOR_CANDIDATE_LEVEL_VALUES])
             .default(DEFAULT_REFACTOR_CANDIDATE_LEVEL),
     );
+    command.option(
+        '--limit <candidate-count>',
+        'Create at most this many refactor prompts, keeping the most important candidates',
+        createPositiveIntegerOptionParser('--limit'),
+    );
 
     command.action(
         handleActionErrors(async (cliOptions) => {
-            const { level = DEFAULT_REFACTOR_CANDIDATE_LEVEL } = cliOptions as {
+            const { level = DEFAULT_REFACTOR_CANDIDATE_LEVEL, limit } = cliOptions as {
                 readonly level?: RefactorCandidateLevel;
+                readonly limit?: number;
             };
 
             // Note: Import the function dynamically to avoid loading heavy dependencies until needed
@@ -57,7 +64,7 @@ export function $initializeCoderFindRefactorCandidatesCommand(program: Program):
             );
 
             try {
-                await findRefactorCandidates({ level });
+                await findRefactorCandidates({ level, limit });
             } catch (error) {
                 assertsError(error);
                 console.error(colors.bgRed(`${error.name}`));

package/src/cli/cli-commands/coder/initializeCoderProjectConfiguration.ts

@@ -8,10 +8,7 @@ import {
     PROMPTS_TEMPLATES_DIRECTORY_PATH,
 } from './boilerplateTemplates';
 import { ensureCoderEnvFile } from './ensureCoderEnvFile';
-import {
-    CODER_AGENTS_DIRECTORY_PATH,
-    ensureCoderDeveloperAgentFile,
-} from './ensureCoderDeveloperAgentFile';
+import { CODER_AGENTS_DIRECTORY_PATH, ensureCoderDeveloperAgentFile } from './ensureCoderDeveloperAgentFile';
 import { ensureCoderGitignoreFile } from './ensureCoderGitignoreFile';
 import { ensureCoderMarkdownFile } from './ensureCoderMarkdownFile';
 import { ensureCoderPackageJsonFile } from './ensureCoderPackageJsonFile';