diff --git a/src/browser/components/CommandPalette/CommandPalette.tsx b/src/browser/components/CommandPalette/CommandPalette.tsx
index a4c260af4e..c727232ade 100644
--- a/src/browser/components/CommandPalette/CommandPalette.tsx
+++ b/src/browser/components/CommandPalette/CommandPalette.tsx
@@ -13,7 +13,7 @@ import {
   matchesKeybind,
 } from "@/browser/utils/ui/keybinds";
 import { stopKeyboardPropagation } from "@/browser/utils/events";
-import { resolveSlashCommandExperimentValue } from "@/browser/utils/slashCommands/experimentVisibility";
+import { createSlashCommandExperimentResolver } from "@/browser/utils/slashCommands/experimentVisibility";
 import { getSlashCommandSuggestions } from "@/browser/utils/slashCommands/suggestions";
 import { CUSTOM_EVENTS, createCustomEvent } from "@/common/constants/events";
 import { EXPERIMENT_IDS } from "@/common/constants/experiments";
@@ -290,10 +290,9 @@ export const CommandPalette: React.FC<CommandPaletteProps> = ({ getSlashContext
       const suggestions = getSlashCommandSuggestions(q, {
         agentSkills,
         variant: ctx.workspaceId ? "workspace" : "creation",
-        isExperimentEnabled: (experimentId) =>
-          resolveSlashCommandExperimentValue(experimentId, {
-            workspaceHeartbeats: workspaceHeartbeatsExperimentEnabled,
-          }),
+        isExperimentEnabled: createSlashCommandExperimentResolver({
+          workspaceHeartbeats: workspaceHeartbeatsExperimentEnabled,
+        }),
       });
       const section = "Slash Commands";
       const groups: PaletteGroup[] = [
diff --git a/src/browser/contexts/WorkspaceContext.tsx b/src/browser/contexts/WorkspaceContext.tsx
index ac82319ce0..943831d4eb 100644
--- a/src/browser/contexts/WorkspaceContext.tsx
+++ b/src/browser/contexts/WorkspaceContext.tsx
@@ -73,6 +73,10 @@ import type { APIClient } from "@/browser/contexts/API";
 import { getErrorMessage } from "@/common/utils/errors";
 import type { WorkspaceCreationScope } from "@/common/utils/subProjects";
 
+// Single source of truth for the guard used when the IPC API client is unavailable, so the
+// message can't drift between the workspace-context operations that surface it.
+const API_NOT_CONNECTED_ERROR = "API not connected";
+
 /**
  * One-time best-effort migration: if the backend doesn't have model preferences yet,
  * persist explicit localStorage values so future port/origin changes keep them.
@@ -1290,7 +1294,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
       trunkBranch: string,
       runtimeConfig?: RuntimeConfig
     ) => {
-      if (!api) throw new Error("API not connected");
+      if (!api) throw new Error(API_NOT_CONNECTED_ERROR);
       console.assert(
         typeof trunkBranch === "string" && trunkBranch.trim().length > 0,
         "Expected trunk branch to be provided when creating a workspace"
@@ -1333,7 +1337,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
       workspaceId: string,
       options?: { force?: boolean }
     ): Promise<{ success: boolean; error?: string }> => {
-      if (!api) return { success: false, error: "API not connected" };
+      if (!api) return { success: false, error: API_NOT_CONNECTED_ERROR };
 
       // Capture state before the async operation.
       // We check currentWorkspaceId (from URL) rather than selectedWorkspace
@@ -1403,7 +1407,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
       workspaceId: string,
       newTitle: string
     ): Promise<{ success: boolean; error?: string }> => {
-      if (!api) return { success: false, error: "API not connected" };
+      if (!api) return { success: false, error: API_NOT_CONNECTED_ERROR };
       try {
         const result = await api.workspace.updateTitle({ workspaceId, title: newTitle });
         if (result.success) {
@@ -1428,7 +1432,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
     async (
       workspaceId: string
     ): Promise<{ success: boolean; error?: string; data?: ArchivePreflightResult }> => {
-      if (!api) return { success: false, error: "API not connected" };
+      if (!api) return { success: false, error: API_NOT_CONNECTED_ERROR };
 
       try {
         const result = await api.workspace.preflightArchive({ workspaceId });
@@ -1448,7 +1452,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
       workspaceId: string,
       options?: { acknowledgedUntrackedPaths?: string[] }
     ): Promise<{ success: boolean; error?: string; data?: ArchiveWorkspaceResult }> => {
-      if (!api) return { success: false, error: "API not connected" };
+      if (!api) return { success: false, error: API_NOT_CONNECTED_ERROR };
 
       try {
         const result = await api.workspace.archive({
@@ -1500,7 +1504,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
 
   const unarchiveWorkspace = useCallback(
     async (workspaceId: string): Promise<{ success: boolean; error?: string }> => {
-      if (!api) return { success: false, error: "API not connected" };
+      if (!api) return { success: false, error: API_NOT_CONNECTED_ERROR };
       try {
         const result = await api.workspace.unarchive({ workspaceId });
         if (result.success) {
diff --git a/src/browser/features/ChatInput/ChatInputToasts.tsx b/src/browser/features/ChatInput/ChatInputToasts.tsx
index 97b671a9f9..b3ff6c027d 100644
--- a/src/browser/features/ChatInput/ChatInputToasts.tsx
+++ b/src/browser/features/ChatInput/ChatInputToasts.tsx
@@ -5,6 +5,10 @@ import type { ParsedCommand } from "@/browser/utils/slashCommands/types";
 import type { SendMessageError as SendMessageErrorType } from "@/common/types/errors";
 import { formatSendMessageError } from "@/common/utils/errors/formatSendError";
 
+// Shared across the provider-related error toasts (missing key, OAuth, disabled,
+// unsupported) so the providers docs link is defined in exactly one place.
+const providersDocsLink = <DocsLink path="/config/providers">mux.coder.com/providers</DocsLink>;
+
 export function createInvalidCompactModelToast(model: string): Toast {
   return {
     id: Date.now().toString(),
@@ -136,7 +140,7 @@ export const createErrorToast = (error: SendMessageErrorType): Toast => {
             <SolutionLabel>Fix:</SolutionLabel>
             {formatted.resolutionHint ?? "Open Settings → Providers and add an API key."}
             <br />
-            <DocsLink path="/config/providers">mux.coder.com/providers</DocsLink>
+            {providersDocsLink}
           </>
         ),
       };
@@ -154,7 +158,7 @@ export const createErrorToast = (error: SendMessageErrorType): Toast => {
             <SolutionLabel>Fix:</SolutionLabel>
             {formatted.resolutionHint ?? "Open Settings → Providers and connect your account."}
             <br />
-            <DocsLink path="/config/providers">mux.coder.com/providers</DocsLink>
+            {providersDocsLink}
           </>
         ),
       };
@@ -172,7 +176,7 @@ export const createErrorToast = (error: SendMessageErrorType): Toast => {
             <SolutionLabel>Fix:</SolutionLabel>
             {formatted.resolutionHint ?? "Open Settings → Providers and enable this provider."}
             <br />
-            <DocsLink path="/config/providers">mux.coder.com/providers</DocsLink>
+            {providersDocsLink}
           </>
         ),
       };
@@ -190,7 +194,7 @@ export const createErrorToast = (error: SendMessageErrorType): Toast => {
             <SolutionLabel>Try This:</SolutionLabel>
             Choose a supported provider in Settings → Providers.
             <br />
-            <DocsLink path="/config/providers">mux.coder.com/providers</DocsLink>
+            {providersDocsLink}
           </>
         ),
       };
diff --git a/src/browser/features/ChatInput/index.tsx b/src/browser/features/ChatInput/index.tsx
index d1772bae2e..bcf8ef73c1 100644
--- a/src/browser/features/ChatInput/index.tsx
+++ b/src/browser/features/ChatInput/index.tsx
@@ -85,7 +85,7 @@ import {
   getSlashCommandSuggestions,
   type SlashSuggestion,
 } from "@/browser/utils/slashCommands/suggestions";
-import { resolveSlashCommandExperimentValue } from "@/browser/utils/slashCommands/experimentVisibility";
+import { createSlashCommandExperimentResolver } from "@/browser/utils/slashCommands/experimentVisibility";
 import { Tooltip, TooltipTrigger, TooltipContent } from "@/browser/components/Tooltip/Tooltip";
 import { AgentModePicker } from "@/browser/components/AgentModePicker/AgentModePicker";
 import { ContextUsageIndicatorButton } from "@/browser/components/ContextUsageIndicatorButton/ContextUsageIndicatorButton";
@@ -1427,10 +1427,9 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
     const suggestions = getSlashCommandSuggestions(input, {
       agentSkills: agentSkillDescriptors,
       variant,
-      isExperimentEnabled: (experimentId) =>
-        resolveSlashCommandExperimentValue(experimentId, {
-          workspaceHeartbeats: workspaceHeartbeatsExperimentEnabled,
-        }),
+      isExperimentEnabled: createSlashCommandExperimentResolver({
+        workspaceHeartbeats: workspaceHeartbeatsExperimentEnabled,
+      }),
     });
     setCommandSuggestions((prev) => replaceSuggestions(prev, suggestions));
     setShowCommandSuggestions(suggestions.length > 0);
@@ -1440,10 +1439,9 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
   // Show only when suggestions are hidden and the input is exactly "/command " with no args yet.
   const commandGhostHint = getCommandGhostHint(input, showCommandSuggestions, {
     variant,
-    isExperimentEnabled: (experimentId) =>
-      resolveSlashCommandExperimentValue(experimentId, {
-        workspaceHeartbeats: workspaceHeartbeatsExperimentEnabled,
-      }),
+    isExperimentEnabled: createSlashCommandExperimentResolver({
+      workspaceHeartbeats: workspaceHeartbeatsExperimentEnabled,
+    }),
   });
 
   // Load agent skills for suggestions
@@ -2849,13 +2847,13 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
                   onDrop={handleDrop}
                   onEscapeInNormalMode={handleEscapeInNormalMode}
                   suppressKeys={
-                    showAtMentionSuggestions
+                    // @file and $skill menus share the same key set; collapse the
+                    // duplicate FILE_SUGGESTION_KEYS branches into one condition.
+                    showAtMentionSuggestions || showSkillSuggestions
                       ? FILE_SUGGESTION_KEYS
-                      : showSkillSuggestions
-                        ? FILE_SUGGESTION_KEYS
-                        : showCommandSuggestions
-                          ? COMMAND_SUGGESTION_KEYS
-                          : undefined
+                      : showCommandSuggestions
+                        ? COMMAND_SUGGESTION_KEYS
+                        : undefined
                   }
                   placeholder={placeholder}
                   disabled={!editingMessageForUi && (disabled || sendInFlightBlocksInput)}
diff --git a/src/browser/features/ChatInput/placeholderTips.test.ts b/src/browser/features/ChatInput/placeholderTips.test.ts
index 44f44ed518..30e27721d5 100644
--- a/src/browser/features/ChatInput/placeholderTips.test.ts
+++ b/src/browser/features/ChatInput/placeholderTips.test.ts
@@ -1,12 +1,10 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { PLACEHOLDER_TIPS, getPlaceholderTip } from "./placeholderTips";
+import { PLACEHOLDER_TIPS, TIP_ROTATION_INTERVAL_MS, getPlaceholderTip } from "./placeholderTips";
 
 interface StorybookGlobal {
   __MUX_STORYBOOK__?: boolean;
 }
 
-const TWENTY_MIN_MS = 20 * 60 * 1000;
-
 describe("PLACEHOLDER_TIPS", () => {
   test("every tip references a slash command", () => {
     for (const tip of PLACEHOLDER_TIPS) {
@@ -43,25 +41,26 @@ describe("getPlaceholderTip", () => {
     // to the same tip. If they don't, switching workspaces / re-rendering
     // inside the same bucket would reshuffle the tip — which is the exact
     // flicker we're trying to prevent.
-    const bucketStart = TWENTY_MIN_MS * 100; // arbitrary aligned anchor
+    const bucketStart = TIP_ROTATION_INTERVAL_MS * 100; // arbitrary aligned anchor
     const tip = getPlaceholderTip(bucketStart);
     expect(getPlaceholderTip(bucketStart + 1)).toBe(tip);
-    expect(getPlaceholderTip(bucketStart + TWENTY_MIN_MS - 1)).toBe(tip);
+    expect(getPlaceholderTip(bucketStart + TIP_ROTATION_INTERVAL_MS - 1)).toBe(tip);
   });
 
   test("advances to the next tip when the bucket boundary crosses", () => {
     // Crossing the boundary must rotate — otherwise the carousel is silently
     // stuck and the discoverability rationale is broken.
-    const bucketStart = TWENTY_MIN_MS * 100;
+    const bucketStart = TIP_ROTATION_INTERVAL_MS * 100;
     const before = getPlaceholderTip(bucketStart);
-    const after = getPlaceholderTip(bucketStart + TWENTY_MIN_MS);
+    const after = getPlaceholderTip(bucketStart + TIP_ROTATION_INTERVAL_MS);
     expect(after).not.toBe(before);
   });
 
   test("wraps with modulo so long-running clocks never lose the placeholder", () => {
     // Far-future timestamps should still resolve to a tip rather than
     // undefined / out-of-bounds.
-    const bigFuture = TWENTY_MIN_MS * PLACEHOLDER_TIPS.length * 5 + TWENTY_MIN_MS * 3;
+    const bigFuture =
+      TIP_ROTATION_INTERVAL_MS * PLACEHOLDER_TIPS.length * 5 + TIP_ROTATION_INTERVAL_MS * 3;
     expect(PLACEHOLDER_TIPS).toContain(getPlaceholderTip(bigFuture));
   });
 
@@ -87,9 +86,9 @@ describe("getPlaceholderTip", () => {
     // Explicit nowMs must still rotate even with the flag set, otherwise
     // unit tests that depend on rotation math would silently no-op when
     // someone forgets to clear the flag.
-    const bucketStart = TWENTY_MIN_MS * 100;
+    const bucketStart = TIP_ROTATION_INTERVAL_MS * 100;
     const before = getPlaceholderTip(bucketStart);
-    const after = getPlaceholderTip(bucketStart + TWENTY_MIN_MS);
+    const after = getPlaceholderTip(bucketStart + TIP_ROTATION_INTERVAL_MS);
     expect(after).not.toBe(before);
   });
 });
diff --git a/src/browser/features/ChatInput/placeholderTips.ts b/src/browser/features/ChatInput/placeholderTips.ts
index fb3e14a70c..f992407bed 100644
--- a/src/browser/features/ChatInput/placeholderTips.ts
+++ b/src/browser/features/ChatInput/placeholderTips.ts
@@ -20,8 +20,9 @@
  * sure the command you're surfacing isn't gated.
  */
 
-/** Bucket length for tip rotation. */
-const TIP_ROTATION_INTERVAL_MS = 20 * 60 * 1000; // 20 minutes
+/** Bucket length for tip rotation. Exported so tests anchor their bucket math
+ * to the real interval instead of a hardcoded copy that silently drifts. */
+export const TIP_ROTATION_INTERVAL_MS = 20 * 60 * 1000; // 20 minutes
 
 /**
  * Tip index pinned for Storybook/Chromatic snapshots.
diff --git a/src/browser/features/ChatInput/types.ts b/src/browser/features/ChatInput/types.ts
index 96b9a13040..713f67a335 100644
--- a/src/browser/features/ChatInput/types.ts
+++ b/src/browser/features/ChatInput/types.ts
@@ -4,7 +4,10 @@ import type { Review } from "@/common/types/review";
 import type { EditingMessageState, PendingUserMessage } from "@/browser/utils/chatEditing";
 import type { SendMessageOptions } from "@/common/orpc/types";
 
-export type GoalInterventionPolicy = NonNullable<SendMessageOptions["goalInterventionPolicy"]>;
+// Re-export so `ChatInput/types` (the existing barrel for ChatInput-local
+// types) stays the single import surface for this feature, while the
+// canonical declaration lives next to `SendMessageOptions` itself.
+export type { GoalInterventionPolicy } from "@/common/orpc/types";
 export type QueueDispatchMode = NonNullable<SendMessageOptions["queueDispatchMode"]>;
 
 export interface ChatInputAPI {
diff --git a/src/browser/features/Messages/Mermaid.tsx b/src/browser/features/Messages/Mermaid.tsx
index 5409f639b1..885dd543e5 100644
--- a/src/browser/features/Messages/Mermaid.tsx
+++ b/src/browser/features/Messages/Mermaid.tsx
@@ -8,6 +8,11 @@ import { usePersistedState } from "@/browser/hooks/usePersistedState";
 const MIN_HEIGHT = 300;
 const MAX_HEIGHT = 1200;
 
+// Sanitizer lookup tables. Hoisted to module scope so they aren't reallocated on
+// every sanitizeMermaidSvg() call (which can run per render for large SVGs).
+const SANITIZER_URL_ATTRIBUTES = new Set(["href", "xlink:href", "src", "action", "formaction"]);
+const SANITIZER_BLOCKED_URL_SCHEMES = ["javascript:", "vbscript:", "data:text/html"];
+
 // Initialize mermaid
 mermaid.initialize({
   startOnLoad: false,
@@ -162,9 +167,6 @@ export function sanitizeMermaidSvg(svg: string): string | null {
     node.remove();
   });
 
-  const urlAttributes = new Set(["href", "xlink:href", "src", "action", "formaction"]);
-  const blockedSchemes = ["javascript:", "vbscript:", "data:text/html"];
-
   const elementsToScan: Element[] = [svgRoot, ...Array.from(svgRoot.querySelectorAll("*"))];
   elementsToScan.forEach((element) => {
     for (const attribute of Array.from(element.attributes)) {
@@ -177,8 +179,8 @@ export function sanitizeMermaidSvg(svg: string): string | null {
       }
 
       if (
-        urlAttributes.has(attributeName) &&
-        blockedSchemes.some((scheme) => canonicalUrlValue.startsWith(scheme))
+        SANITIZER_URL_ATTRIBUTES.has(attributeName) &&
+        SANITIZER_BLOCKED_URL_SCHEMES.some((scheme) => canonicalUrlValue.startsWith(scheme))
       ) {
         element.removeAttribute(attribute.name);
       }
diff --git a/src/browser/features/RightSidebar/CodeReview/ImmersiveMinimap.tsx b/src/browser/features/RightSidebar/CodeReview/ImmersiveMinimap.tsx
index 4ab030466d..7ec7172dd8 100644
--- a/src/browser/features/RightSidebar/CodeReview/ImmersiveMinimap.tsx
+++ b/src/browser/features/RightSidebar/CodeReview/ImmersiveMinimap.tsx
@@ -30,6 +30,18 @@ const readThemeColor = (cssVariableName: string, fallback: string): string => {
   return resolvedColor.length > 0 ? resolvedColor : fallback;
 };
 
+// The minimap reads thumb geometry from a scroll container in three places
+// (initial draw, thumb press, and drag-follow), each needing the same
+// scrollTop/scrollHeight/clientHeight triple. Funnel them through one wrapper
+// so the call sites stay in sync; pure forwarding, no behavior change.
+const getScrollContainerThumbMetrics = (scrollContainer: HTMLElement, trackHeight: number) =>
+  getThumbMetrics(
+    scrollContainer.scrollTop,
+    scrollContainer.scrollHeight,
+    scrollContainer.clientHeight,
+    trackHeight
+  );
+
 export const ImmersiveMinimap: React.FC<ImmersiveMinimapProps> = (props) => {
   // Computed synchronously during render — React Compiler memoizes based on
   // props.content. Avoids the useState+useEffect flash where the component
@@ -105,10 +117,8 @@ export const ImmersiveMinimap: React.FC<ImmersiveMinimapProps> = (props) => {
 
     const scrollContainer = props.scrollContainerRef.current;
     if (scrollContainer) {
-      const { thumbTop, thumbHeight } = getThumbMetrics(
-        scrollContainer.scrollTop,
-        scrollContainer.scrollHeight,
-        scrollContainer.clientHeight,
+      const { thumbTop, thumbHeight } = getScrollContainerThumbMetrics(
+        scrollContainer,
         trackHeight
       );
 
@@ -196,12 +206,7 @@ export const ImmersiveMinimap: React.FC<ImmersiveMinimapProps> = (props) => {
       const pointerY = event.clientY - bounds.top;
 
       if (scrollContainer) {
-        const thumbMetrics = getThumbMetrics(
-          scrollContainer.scrollTop,
-          scrollContainer.scrollHeight,
-          scrollContainer.clientHeight,
-          bounds.height
-        );
+        const thumbMetrics = getScrollContainerThumbMetrics(scrollContainer, bounds.height);
 
         const isPressingThumb =
           thumbMetrics.maxThumbTop > 0 &&
@@ -223,10 +228,8 @@ export const ImmersiveMinimap: React.FC<ImmersiveMinimapProps> = (props) => {
 
             const latestBounds = latestCanvas.getBoundingClientRect();
             const nextPointerY = moveEvent.clientY - latestBounds.top;
-            const nextMetrics = getThumbMetrics(
-              latestScrollContainer.scrollTop,
-              latestScrollContainer.scrollHeight,
-              latestScrollContainer.clientHeight,
+            const nextMetrics = getScrollContainerThumbMetrics(
+              latestScrollContainer,
               latestBounds.height
             );
             const nextThumbTop = clamp(nextPointerY - pointerOffset, 0, nextMetrics.maxThumbTop);
diff --git a/src/browser/features/RightSidebar/CodeReview/ImmersiveReviewView.tsx b/src/browser/features/RightSidebar/CodeReview/ImmersiveReviewView.tsx
index 5bf1bad1d7..82e663728f 100644
--- a/src/browser/features/RightSidebar/CodeReview/ImmersiveReviewView.tsx
+++ b/src/browser/features/RightSidebar/CodeReview/ImmersiveReviewView.tsx
@@ -1561,6 +1561,22 @@ export const ImmersiveReviewView: React.FC<ImmersiveReviewViewProps> = (props) =
     const contentChanged = previousContentRef.current !== overlayData.content;
     previousContentRef.current = overlayData.content;
 
+    // Clear the file-switch reveal gate on the next frame once the initial scroll
+    // has been issued. Both the no-line-element retry path and the post-scroll path
+    // need the identical "cancel any pending frame, then schedule a one-shot clear
+    // guarded by the captured file path" sequence, so keep it in one place.
+    const scheduleRevealCompletion = (revealFilePath: string) => {
+      if (revealAnimationFrameRef.current !== null) {
+        cancelAnimationFrame(revealAnimationFrameRef.current);
+      }
+      revealAnimationFrameRef.current = window.requestAnimationFrame(() => {
+        setPendingRevealFilePath((pendingFilePath) =>
+          pendingFilePath === revealFilePath ? null : pendingFilePath
+        );
+        revealAnimationFrameRef.current = null;
+      });
+    };
+
     const previousLineElement = highlightedLineElementRef.current;
     if (previousLineElement) {
       previousLineElement.style.outline = "";
@@ -1596,17 +1612,7 @@ export const ImmersiveReviewView: React.FC<ImmersiveReviewViewProps> = (props) =
         return;
       }
 
-      if (revealAnimationFrameRef.current !== null) {
-        cancelAnimationFrame(revealAnimationFrameRef.current);
-      }
-
-      const revealFilePath = activeFilePath;
-      revealAnimationFrameRef.current = window.requestAnimationFrame(() => {
-        setPendingRevealFilePath((pendingFilePath) =>
-          pendingFilePath === revealFilePath ? null : pendingFilePath
-        );
-        revealAnimationFrameRef.current = null;
-      });
+      scheduleRevealCompletion(activeFilePath);
       return;
     }
 
@@ -1627,17 +1633,7 @@ export const ImmersiveReviewView: React.FC<ImmersiveReviewViewProps> = (props) =
       return;
     }
 
-    if (revealAnimationFrameRef.current !== null) {
-      cancelAnimationFrame(revealAnimationFrameRef.current);
-    }
-
-    const revealFilePath = activeFilePath;
-    revealAnimationFrameRef.current = window.requestAnimationFrame(() => {
-      setPendingRevealFilePath((pendingFilePath) =>
-        pendingFilePath === revealFilePath ? null : pendingFilePath
-      );
-      revealAnimationFrameRef.current = null;
-    });
+    scheduleRevealCompletion(activeFilePath);
   }, [
     activeFilePath,
     activeLineIndex,
diff --git a/src/browser/features/RightSidebar/CodeReview/ReviewPanel.assistedStats.test.ts b/src/browser/features/RightSidebar/CodeReview/ReviewPanel.assistedStats.test.ts
index 8e079bc458..f897ab1bee 100644
--- a/src/browser/features/RightSidebar/CodeReview/ReviewPanel.assistedStats.test.ts
+++ b/src/browser/features/RightSidebar/CodeReview/ReviewPanel.assistedStats.test.ts
@@ -1,8 +1,8 @@
 import { describe, expect, test } from "bun:test";
 
 import type { AssistedReviewHunk, DiffHunk } from "@/common/types/review";
+import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 import {
-  buildReviewDiffPathFilter,
   buildReviewDiffPathFilterSpecs,
   countUnreadAssistedHunks,
   getEffectiveReviewFrontendFilters,
@@ -10,6 +10,27 @@ import {
   getNextDismissedAssistedKeys,
 } from "./ReviewPanel";
 
+// Test-only single-result wrapper around `buildReviewDiffPathFilterSpecs`.
+// Production callers go through the multi-spec form directly to handle the
+// multi-project case; these tests only exercise the first spec's pathFilter,
+// so the wrapper lives here instead of polluting ReviewPanel's exported API.
+function buildReviewDiffPathFilter(params: {
+  isImmersive: boolean;
+  assistedOnly: boolean;
+  assistedHunks: readonly AssistedReviewHunk[];
+  selectedFilePath: string | null;
+  selectedDiffPath: string;
+  workspaceMetadata: Pick<FrontendWorkspaceMetadata, "projects"> | null | undefined;
+  repoRootProjectPath: string | null | undefined;
+}): string {
+  return (
+    buildReviewDiffPathFilterSpecs({
+      ...params,
+      projectPath: params.repoRootProjectPath ?? "",
+    })[0]?.pathFilter ?? ""
+  );
+}
+
 function hunk(overrides: Partial<DiffHunk>): DiffHunk {
   return {
     id: overrides.id ?? "h1",
diff --git a/src/browser/features/RightSidebar/CodeReview/ReviewPanel.tsx b/src/browser/features/RightSidebar/CodeReview/ReviewPanel.tsx
index 5a6733b1a0..b9fa9f77cc 100644
--- a/src/browser/features/RightSidebar/CodeReview/ReviewPanel.tsx
+++ b/src/browser/features/RightSidebar/CodeReview/ReviewPanel.tsx
@@ -32,7 +32,11 @@ import React, {
   useRef,
   useSyncExternalStore,
 } from "react";
-import { findAssistedMatch, formatAssistedFilter } from "@/common/utils/review/assistedReview";
+import {
+  filterDismissedAssistedHunks,
+  findAssistedMatch,
+  formatAssistedFilter,
+} from "@/common/utils/review/assistedReview";
 import { createPortal } from "react-dom";
 import { HunkViewer } from "./HunkViewer";
 import { InlineReviewNote, type ReviewActionCallbacks } from "../../Shared/InlineReviewNote";
@@ -529,23 +533,6 @@ export function buildReviewDiffPathFilterSpecs(params: {
   }));
 }
 
-export function buildReviewDiffPathFilter(params: {
-  isImmersive: boolean;
-  assistedOnly: boolean;
-  assistedHunks: readonly AssistedReviewHunk[];
-  selectedFilePath: string | null;
-  selectedDiffPath: string;
-  workspaceMetadata: Pick<FrontendWorkspaceMetadata, "projects"> | null | undefined;
-  repoRootProjectPath: string | null | undefined;
-}): string {
-  return (
-    buildReviewDiffPathFilterSpecs({
-      ...params,
-      projectPath: params.repoRootProjectPath ?? "",
-    })[0]?.pathFilter ?? ""
-  );
-}
-
 export function getEffectiveReviewIncludeUncommitted(params: {
   assistedOnly: boolean;
   includeUncommitted: boolean;
@@ -639,11 +626,10 @@ export const ReviewAssistedStatsReporter: React.FC<ReviewAssistedStatsReporterPr
     [],
     { listener: true }
   );
-  const assistedHunks = useMemo(() => {
-    if (dismissedAssistedKeys.length === 0) return rawAssistedHunks;
-    const dismissed = new Set(dismissedAssistedKeys);
-    return rawAssistedHunks.filter((entry) => !dismissed.has(formatAssistedFilter(entry)));
-  }, [rawAssistedHunks, dismissedAssistedKeys]);
+  const assistedHunks = useMemo(
+    () => filterDismissedAssistedHunks(rawAssistedHunks, dismissedAssistedKeys),
+    [rawAssistedHunks, dismissedAssistedKeys]
+  );
 
   // Self-heal the dismissed-pin list whenever the agent's set changes:
   // drop any dismissed key that is no longer present in the agent's pins
@@ -1091,19 +1077,12 @@ export const ReviewPanel: React.FC<ReviewPanelProps> = ({
     [],
     { listener: true }
   );
-  const dismissedAssistedKeySet = useMemo(
-    () => new Set(dismissedAssistedKeys),
-    [dismissedAssistedKeys]
-  );
-
   // Effective assisted set after applying user dismissals. Memoized so all
   // downstream maps depend on a stable reference when nothing changes.
-  const assistedHunks = useMemo(() => {
-    if (dismissedAssistedKeySet.size === 0) return rawAssistedHunks;
-    return rawAssistedHunks.filter(
-      (entry) => !dismissedAssistedKeySet.has(formatAssistedFilter(entry))
-    );
-  }, [rawAssistedHunks, dismissedAssistedKeySet]);
+  const assistedHunks = useMemo(
+    () => filterDismissedAssistedHunks(rawAssistedHunks, dismissedAssistedKeys),
+    [rawAssistedHunks, dismissedAssistedKeys]
+  );
 
   // The self-healing prune of stale dismissed keys lives in
   // `ReviewAssistedStatsReporter` (always mounted) so it runs even when the
diff --git a/src/browser/features/RightSidebar/GoalTab.tsx b/src/browser/features/RightSidebar/GoalTab.tsx
index e33cb9b9fc..3ce6a8f145 100644
--- a/src/browser/features/RightSidebar/GoalTab.tsx
+++ b/src/browser/features/RightSidebar/GoalTab.tsx
@@ -90,6 +90,16 @@ interface GoalTabProps {
 const parseBudgetInput = parseGoalBudgetInputCents;
 const parseTurnCapInput = parseGoalTurnCapInput;
 
+// Shared className for the neutral lifecycle action buttons in the active-goal
+// header (Pause / Mark complete / Reopen). All three render with the same
+// bordered surface-secondary chip styling so they read as visual peers; the
+// accent-colored Archive and success-tinted Resume buttons keep their own
+// inline class strings because they are the only primary / positive variants.
+// Centralizing the neutral string here keeps the next tone tweak to those
+// three buttons a one-line edit instead of three duplicated copies.
+const GOAL_LIFECYCLE_NEUTRAL_BUTTON_CLASS =
+  "border-border-light bg-surface-secondary text-foreground hover:bg-surface-tertiary inline-flex items-center gap-1.5 rounded-md border px-3 py-1.5 text-sm";
+
 type EditingField = "objective" | "budget" | "turnCap";
 
 export function GoalTab(props: GoalTabProps) {
@@ -613,7 +623,7 @@ export function GoalTab(props: GoalTabProps) {
           {canPause && (
             <button
               type="button"
-              className="border-border-light bg-surface-secondary text-foreground hover:bg-surface-tertiary inline-flex items-center gap-1.5 rounded-md border px-3 py-1.5 text-sm"
+              className={GOAL_LIFECYCLE_NEUTRAL_BUTTON_CLASS}
               aria-label="Pause goal"
               onClick={() => void setStatus("paused")}
             >
@@ -641,7 +651,7 @@ export function GoalTab(props: GoalTabProps) {
           {canComplete && (
             <button
               type="button"
-              className="border-border-light bg-surface-secondary text-foreground hover:bg-surface-tertiary inline-flex items-center gap-1.5 rounded-md border px-3 py-1.5 text-sm"
+              className={GOAL_LIFECYCLE_NEUTRAL_BUTTON_CLASS}
               aria-label="Mark goal complete"
               onClick={(event) => openSummaryInput(event.currentTarget)}
             >
@@ -660,7 +670,7 @@ export function GoalTab(props: GoalTabProps) {
             <>
               <button
                 type="button"
-                className="border-border-light bg-surface-secondary text-foreground hover:bg-surface-tertiary inline-flex items-center gap-1.5 rounded-md border px-3 py-1.5 text-sm"
+                className={GOAL_LIFECYCLE_NEUTRAL_BUTTON_CLASS}
                 aria-label="Reopen goal"
                 onClick={() => void setStatus("active")}
               >
@@ -792,6 +802,39 @@ export function GoalTab(props: GoalTabProps) {
   );
 }
 
+interface StatTileHeaderProps {
+  /** Tile label rendered as a `<dt>` (the parent `<dl>` lives in the active-goal section). */
+  label: string;
+  canEdit: boolean;
+  /** Aria label for the inline "Edit" button — distinguishes the budget vs turn-cap openers in tests + a11y. */
+  editAriaLabel: string;
+  onEdit: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}
+
+/**
+ * Shared header row for the active-goal stat tiles (Budget, Turns):
+ * a `<dt>` label on the left and an optional inline "Edit" button on
+ * the right. Kept scoped to this file because the styling is intentionally
+ * local to the dashboard tile look and not reused elsewhere.
+ */
+function StatTileHeader(props: StatTileHeaderProps) {
+  return (
+    <div className="flex items-baseline justify-between gap-2">
+      <dt className="text-muted text-xs">{props.label}</dt>
+      {props.canEdit && (
+        <button
+          type="button"
+          className="text-muted hover:text-foreground text-xs underline"
+          aria-label={props.editAriaLabel}
+          onClick={props.onEdit}
+        >
+          Edit
+        </button>
+      )}
+    </div>
+  );
+}
+
 interface BudgetTileProps {
   costCents: number;
   budgetCents: number | null;
@@ -853,19 +896,12 @@ function BudgetTile(props: BudgetTileProps) {
 
   return (
     <div className="bg-surface-secondary col-span-2 rounded-md p-3">
-      <div className="flex items-baseline justify-between gap-2">
-        <dt className="text-muted text-xs">Budget</dt>
-        {canEdit && (
-          <button
-            type="button"
-            className="text-muted hover:text-foreground text-xs underline"
-            aria-label="Edit goal budget"
-            onClick={onEdit}
-          >
-            Edit
-          </button>
-        )}
-      </div>
+      <StatTileHeader
+        label="Budget"
+        canEdit={canEdit}
+        editAriaLabel="Edit goal budget"
+        onEdit={onEdit}
+      />
       <dd className="counter-nums text-foreground mt-1 flex items-baseline justify-between gap-3 leading-tight">
         <span className="text-base font-medium">
           <span>{formatGoalCents(costCents)}</span>
@@ -939,19 +975,12 @@ function TurnsTile(props: TurnsTileProps) {
 
   return (
     <div className="bg-surface-secondary rounded-md p-3">
-      <div className="flex items-baseline justify-between gap-2">
-        <dt className="text-muted text-xs">Turns</dt>
-        {canEdit && (
-          <button
-            type="button"
-            className="text-muted hover:text-foreground text-xs underline"
-            aria-label="Edit goal turn cap"
-            onClick={onEdit}
-          >
-            Edit
-          </button>
-        )}
-      </div>
+      <StatTileHeader
+        label="Turns"
+        canEdit={canEdit}
+        editAriaLabel="Edit goal turn cap"
+        onEdit={onEdit}
+      />
       <dd className="counter-nums text-foreground mt-1 leading-tight">
         <div className="text-base font-medium">
           <span>{hasCap ? `${turnsUsed} / ${turnCap}` : String(turnsUsed)}</span>
diff --git a/src/browser/features/Settings/Components/OnePasswordPicker.tsx b/src/browser/features/Settings/Components/OnePasswordPicker.tsx
index 20b1ddd713..6365efdd11 100644
--- a/src/browser/features/Settings/Components/OnePasswordPicker.tsx
+++ b/src/browser/features/Settings/Components/OnePasswordPicker.tsx
@@ -6,6 +6,10 @@ import { useAPI } from "@/browser/contexts/API";
 import assert from "@/common/utils/assert";
 import { getErrorMessage } from "@/common/utils/errors";
 
+// Single source of truth for the guard shown when the IPC API client is unavailable, so the
+// message can't drift between the four picker fetch handlers that surface it.
+const API_NOT_CONNECTED_ERROR = "Mux API not connected.";
+
 interface OnePasswordVault {
   id: string;
   title: string;
@@ -50,7 +54,7 @@ export function OnePasswordPicker(props: OnePasswordPickerProps) {
   useEffect(() => {
     if (!api) {
       setVaults([]);
-      setError("Mux API not connected.");
+      setError(API_NOT_CONNECTED_ERROR);
       setLoading(false);
       return;
     }
@@ -112,7 +116,7 @@ export function OnePasswordPicker(props: OnePasswordPickerProps) {
     assert(vault.title.length > 0, "OnePasswordPicker: vault.title must be non-empty");
 
     if (!api) {
-      setError("Mux API not connected.");
+      setError(API_NOT_CONNECTED_ERROR);
       return;
     }
 
@@ -148,7 +152,7 @@ export function OnePasswordPicker(props: OnePasswordPickerProps) {
     assert(item.title.length > 0, "OnePasswordPicker: item.title must be non-empty");
 
     if (!api) {
-      setError("Mux API not connected.");
+      setError(API_NOT_CONNECTED_ERROR);
       return;
     }
 
@@ -191,7 +195,7 @@ export function OnePasswordPicker(props: OnePasswordPickerProps) {
     assert(field.title.length > 0, "OnePasswordPicker: field.title must be non-empty");
 
     if (!api) {
-      setError("Mux API not connected.");
+      setError(API_NOT_CONNECTED_ERROR);
       return;
     }
 
diff --git a/src/browser/features/Settings/Sections/GeneralSection.tsx b/src/browser/features/Settings/Sections/GeneralSection.tsx
index b5a9d59feb..61be8f6e08 100644
--- a/src/browser/features/Settings/Sections/GeneralSection.tsx
+++ b/src/browser/features/Settings/Sections/GeneralSection.tsx
@@ -9,7 +9,8 @@ import {
 } from "@/browser/components/SelectPrimitive/SelectPrimitive";
 import { Input } from "@/browser/components/Input/Input";
 import { Switch } from "@/browser/components/Switch/Switch";
-import { updatePersistedState, usePersistedState } from "@/browser/hooks/usePersistedState";
+import { usePersistedState } from "@/browser/hooks/usePersistedState";
+import { persistChatTranscriptFullWidth } from "@/browser/hooks/useChatTranscriptFullWidth";
 import { useAPI } from "@/browser/contexts/API";
 import { CUSTOM_EVENTS, createCustomEvent } from "@/common/constants/events";
 import {
@@ -20,7 +21,6 @@ import {
   LAUNCH_BEHAVIOR_KEY,
   BASH_COLLAPSED_SUMMARY_MODE_KEY,
   BASH_COLLAPSED_SUMMARY_MODES,
-  CHAT_TRANSCRIPT_FULL_WIDTH_KEY,
   DEFAULT_BASH_COLLAPSED_SUMMARY_MODE,
   normalizeBashCollapsedSummaryMode,
   type BashCollapsedSummaryMode,
@@ -283,10 +283,7 @@ export function GeneralSection() {
         if (chatTranscriptFullWidthNonce === chatTranscriptFullWidthLoadNonceRef.current) {
           const enabled = cfg.chatTranscriptFullWidth === true;
           setChatTranscriptFullWidth(enabled);
-          updatePersistedState<boolean | undefined>(
-            CHAT_TRANSCRIPT_FULL_WIDTH_KEY,
-            enabled ? true : undefined
-          );
+          persistChatTranscriptFullWidth(enabled);
         }
 
         if (llmDebugLogsNonce === llmDebugLogsLoadNonceRef.current) {
@@ -379,10 +376,7 @@ export function GeneralSection() {
     // Invalidate any in-flight config load so it does not overwrite the user's selection.
     chatTranscriptFullWidthLoadNonceRef.current++;
     setChatTranscriptFullWidth(checked);
-    updatePersistedState<boolean | undefined>(
-      CHAT_TRANSCRIPT_FULL_WIDTH_KEY,
-      checked ? true : undefined
-    );
+    persistChatTranscriptFullWidth(checked);
 
     if (!api?.config?.updateChatTranscriptFullWidth) {
       return;
diff --git a/src/browser/features/Settings/Sections/ProvidersSection.tsx b/src/browser/features/Settings/Sections/ProvidersSection.tsx
index 4bf8560d72..526fca62b8 100644
--- a/src/browser/features/Settings/Sections/ProvidersSection.tsx
+++ b/src/browser/features/Settings/Sections/ProvidersSection.tsx
@@ -86,6 +86,10 @@ type CopilotLoginStatus = "idle" | "starting" | "waiting" | "success" | "error";
 
 const OPENAI_SERVICE_TIER_UNSET = "unset";
 
+// Single source of truth for the guard shown when the IPC API client is unavailable, so the
+// message can't drift between the several provider login/submit handlers that surface it.
+const API_NOT_CONNECTED_ERROR = "Mux API not connected.";
+
 type OpenAIServiceTier = ServiceTier;
 type OpenAIServiceTierSelectValue = typeof OPENAI_SERVICE_TIER_UNSET | OpenAIServiceTier;
 
@@ -493,7 +497,7 @@ export function ProvidersSection() {
 
     if (!api) {
       setCodexOauthStatus("error");
-      setCodexOauthError("Mux API not connected.");
+      setCodexOauthError(API_NOT_CONNECTED_ERROR);
       return;
     }
 
@@ -609,7 +613,7 @@ export function ProvidersSection() {
 
     if (!api) {
       setCodexOauthStatus("error");
-      setCodexOauthError("Mux API not connected.");
+      setCodexOauthError(API_NOT_CONNECTED_ERROR);
       return;
     }
 
@@ -683,7 +687,7 @@ export function ProvidersSection() {
 
     if (!api) {
       setCodexOauthStatus("error");
-      setCodexOauthError("Mux API not connected.");
+      setCodexOauthError(API_NOT_CONNECTED_ERROR);
       return;
     }
 
@@ -801,7 +805,7 @@ export function ProvidersSection() {
       if (isDesktop) {
         if (!api) {
           setMuxGatewayLoginStatus("error");
-          setMuxGatewayLoginError("Mux API not connected.");
+          setMuxGatewayLoginError(API_NOT_CONNECTED_ERROR);
           return;
         }
 
@@ -1414,7 +1418,7 @@ export function ProvidersSection() {
     setCustomProviderSubmitAttempted(true);
 
     if (!api) {
-      setCustomProviderSubmitError("Mux API not connected.");
+      setCustomProviderSubmitError(API_NOT_CONNECTED_ERROR);
       return;
     }
 
@@ -1503,7 +1507,7 @@ export function ProvidersSection() {
       if (!api) {
         setCustomProviderRemoveErrors((prev) => ({
           ...prev,
-          [provider]: "Mux API not connected.",
+          [provider]: API_NOT_CONNECTED_ERROR,
         }));
         return;
       }
diff --git a/src/browser/features/Settings/Sections/TasksSection.tsx b/src/browser/features/Settings/Sections/TasksSection.tsx
index f35ad23f34..01fa4267f0 100644
--- a/src/browser/features/Settings/Sections/TasksSection.tsx
+++ b/src/browser/features/Settings/Sections/TasksSection.tsx
@@ -291,6 +291,41 @@ function getAdvisorSwitchState(
   return { checked, title };
 }
 
+// Renders the per-agent advisor toggle (Tooltip + Switch + optional Reset button).
+// The same block previously lived inline in renderAgentDefaults and
+// renderUnknownAgentDefaults; extracting it keeps the two call sites byte-for-byte
+// identical (same aria-label, same tooltip text, same reset semantics).
+function AdvisorSwitch(props: {
+  agentId: string;
+  advisorEnabledOverride: boolean | undefined;
+  onChange: (checked: boolean) => void;
+  onReset: () => void;
+}): React.ReactNode {
+  const state = getAdvisorSwitchState(props.agentId, props.advisorEnabledOverride);
+  return (
+    <>
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <div className="flex items-center gap-2">
+            <div className="text-muted text-xs">Advisor</div>
+            <Switch
+              checked={state.checked}
+              onCheckedChange={props.onChange}
+              aria-label={`Toggle ${props.agentId} advisor`}
+            />
+          </div>
+        </TooltipTrigger>
+        <TooltipContent>{state.title}</TooltipContent>
+      </Tooltip>
+      {props.advisorEnabledOverride !== undefined ? (
+        <Button type="button" variant="ghost" size="sm" className="px-2" onClick={props.onReset}>
+          Reset
+        </Button>
+      ) : null}
+    </>
+  );
+}
+
 function areTaskSettingsEqual(a: TaskSettings, b: TaskSettings): boolean {
   return (
     a.maxParallelAgentTasks === b.maxParallelAgentTasks &&
@@ -881,7 +916,6 @@ export function TasksSection() {
     const writesSubagentAiDefaults = agent.subagentRunnable && !agent.uiSelectable;
     const enabledOverride = entry?.enabled;
     const advisorEnabledOverride = entry?.advisorEnabled;
-    const advisorSwitchState = getAdvisorSwitchState(agent.id, advisorEnabledOverride);
 
     const enablementLocked =
       agent.id === "exec" || agent.id === "plan" || agent.id === "compact" || agent.id === "mux";
@@ -1001,30 +1035,12 @@ export function TasksSection() {
             </div>
             {advisorToolEnabled ? (
               <div className="flex items-center gap-3">
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <div className="flex items-center gap-2">
-                      <div className="text-muted text-xs">Advisor</div>
-                      <Switch
-                        checked={advisorSwitchState.checked}
-                        onCheckedChange={(checked) => setAgentAdvisorEnabled(agent.id, checked)}
-                        aria-label={`Toggle ${agent.id} advisor`}
-                      />
-                    </div>
-                  </TooltipTrigger>
-                  <TooltipContent>{advisorSwitchState.title}</TooltipContent>
-                </Tooltip>
-                {advisorEnabledOverride !== undefined ? (
-                  <Button
-                    type="button"
-                    variant="ghost"
-                    size="sm"
-                    className="px-2"
-                    onClick={() => resetAgentAdvisorEnabled(agent.id)}
-                  >
-                    Reset
-                  </Button>
-                ) : null}
+                <AdvisorSwitch
+                  agentId={agent.id}
+                  advisorEnabledOverride={advisorEnabledOverride}
+                  onChange={(checked) => setAgentAdvisorEnabled(agent.id, checked)}
+                  onReset={() => resetAgentAdvisorEnabled(agent.id)}
+                />
               </div>
             ) : null}
           </div>
@@ -1106,7 +1122,6 @@ export function TasksSection() {
     const modelValue = entry?.modelString ?? INHERIT;
     const thinkingValue = entry?.thinkingLevel ?? INHERIT;
     const advisorEnabledOverride = entry?.advisorEnabled;
-    const advisorSwitchState = getAdvisorSwitchState(agentId, advisorEnabledOverride);
     const effectiveModel = modelValue !== INHERIT ? modelValue : inheritedEffectiveModel;
 
     return (
@@ -1121,30 +1136,12 @@ export function TasksSection() {
           </div>
           {advisorToolEnabled ? (
             <div className="flex shrink-0 items-center gap-3">
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <div className="flex items-center gap-2">
-                    <div className="text-muted text-xs">Advisor</div>
-                    <Switch
-                      checked={advisorSwitchState.checked}
-                      onCheckedChange={(checked) => setAgentAdvisorEnabled(agentId, checked)}
-                      aria-label={`Toggle ${agentId} advisor`}
-                    />
-                  </div>
-                </TooltipTrigger>
-                <TooltipContent>{advisorSwitchState.title}</TooltipContent>
-              </Tooltip>
-              {advisorEnabledOverride !== undefined ? (
-                <Button
-                  type="button"
-                  variant="ghost"
-                  size="sm"
-                  className="px-2"
-                  onClick={() => resetAgentAdvisorEnabled(agentId)}
-                >
-                  Reset
-                </Button>
-              ) : null}
+              <AdvisorSwitch
+                agentId={agentId}
+                advisorEnabledOverride={advisorEnabledOverride}
+                onChange={(checked) => setAgentAdvisorEnabled(agentId, checked)}
+                onReset={() => resetAgentAdvisorEnabled(agentId)}
+              />
             </div>
           ) : null}
         </div>
diff --git a/src/browser/features/Tools/AdvisorToolCall.tsx b/src/browser/features/Tools/AdvisorToolCall.tsx
index 0422329bc9..049bd5db03 100644
--- a/src/browser/features/Tools/AdvisorToolCall.tsx
+++ b/src/browser/features/Tools/AdvisorToolCall.tsx
@@ -144,16 +144,24 @@ function formatAdvisorModel(advisorModel: string): { displayName: string; rawMod
   };
 }
 
+// The `advice`, `error`, and executing/fallback cases all present their state
+// through the shared status-display helper and differ only in the status they
+// pass. Centralize that { status, content } shape so the three branches don't
+// each re-derive it; `limit_reached` keeps its custom warning content.
+function defaultAdvisorStatusPresentation(status: ToolStatus): AdvisorStatusPresentation {
+  return {
+    status,
+    content: getStatusDisplay(status),
+  };
+}
+
 function getAdvisorStatusPresentation(
   result: AdvisorToolResult | null,
   fallbackStatus: ToolStatus
 ): AdvisorStatusPresentation {
   switch (result?.type) {
     case "advice":
-      return {
-        status: "completed",
-        content: getStatusDisplay("completed"),
-      };
+      return defaultAdvisorStatusPresentation("completed");
     case "limit_reached":
       return {
         status: "completed",
@@ -166,15 +174,9 @@ function getAdvisorStatusPresentation(
         ),
       };
     case "error":
-      return {
-        status: "failed",
-        content: getStatusDisplay("failed"),
-      };
+      return defaultAdvisorStatusPresentation("failed");
     default:
-      return {
-        status: fallbackStatus,
-        content: getStatusDisplay(fallbackStatus),
-      };
+      return defaultAdvisorStatusPresentation(fallbackStatus);
   }
 }
 
diff --git a/src/browser/features/Tools/AskUserQuestionToolCall.tsx b/src/browser/features/Tools/AskUserQuestionToolCall.tsx
index d948712d6c..114b15e065 100644
--- a/src/browser/features/Tools/AskUserQuestionToolCall.tsx
+++ b/src/browser/features/Tools/AskUserQuestionToolCall.tsx
@@ -179,6 +179,23 @@ function getDescriptionsForLabels(question: AskUserQuestionQuestion, labels: str
     .filter((d): d is string => d !== undefined);
 }
 
+/**
+ * Shared class string for the section-selector pills in the executing UI
+ * (one pill per question plus the Summary pill). Both pills paint with the
+ * same three visual states: selected (accent), complete (success-tinted),
+ * or pending (neutral).
+ */
+function getSectionPillClassName(isSelected: boolean, isComplete: boolean): string {
+  return cn(
+    "inline-flex items-center gap-1 rounded-full border px-2.5 py-0.5 text-[11px] font-medium transition-colors",
+    isSelected
+      ? "border-accent bg-accent text-accent-foreground shadow-sm"
+      : isComplete
+        ? "border-success/40 bg-success/10 text-success hover:bg-success/20"
+        : "border-white/10 bg-white/5 text-secondary hover:border-white/20 hover:text-foreground"
+  );
+}
+
 /** Auto-resizing textarea for "Other" text input. */
 function AutoResizeTextarea(props: {
   value: string;
@@ -592,14 +609,7 @@ export function AskUserQuestionToolCall(props: {
                       <button
                         key={q.question}
                         type="button"
-                        className={cn(
-                          "inline-flex items-center gap-1 rounded-full border px-2.5 py-0.5 text-[11px] font-medium transition-colors",
-                          isActive
-                            ? "border-accent bg-accent text-accent-foreground shadow-sm"
-                            : answered
-                              ? "border-success/40 bg-success/10 text-success hover:bg-success/20"
-                              : "border-white/10 bg-white/5 text-secondary hover:border-white/20 hover:text-foreground"
-                        )}
+                        className={getSectionPillClassName(isActive, answered)}
                         onClick={() => setActiveIndex(idx)}
                       >
                         {q.header}
@@ -609,14 +619,7 @@ export function AskUserQuestionToolCall(props: {
                   })}
                   <button
                     type="button"
-                    className={cn(
-                      "inline-flex items-center gap-1 rounded-full border px-2.5 py-0.5 text-[11px] font-medium transition-colors",
-                      isOnSummary
-                        ? "border-accent bg-accent text-accent-foreground shadow-sm"
-                        : isComplete
-                          ? "border-success/40 bg-success/10 text-success hover:bg-success/20"
-                          : "border-white/10 bg-white/5 text-secondary hover:border-white/20 hover:text-foreground"
-                    )}
+                    className={getSectionPillClassName(isOnSummary, isComplete)}
                     onClick={() => setActiveIndex(summaryIndex)}
                   >
                     Summary
diff --git a/src/browser/features/Tools/bashCollapsedSummary.ts b/src/browser/features/Tools/bashCollapsedSummary.ts
index 49c164e0f7..36e27a7e39 100644
--- a/src/browser/features/Tools/bashCollapsedSummary.ts
+++ b/src/browser/features/Tools/bashCollapsedSummary.ts
@@ -38,10 +38,7 @@ export function buildBashCollapsedSummary(
   }
 
   const intent = sanitizeModelIntent(options.args.model_intent, command);
-  const displayIntent =
-    intent && normalizeForComparison(intent) !== normalizeForComparison(command)
-      ? intent
-      : undefined;
+  const displayIntent = intent && !matchesCommand(intent, command) ? intent : undefined;
   if (mode === "intent") {
     return {
       kind: "intent",
@@ -93,7 +90,7 @@ export function sanitizeModelIntent(rawIntent: unknown, command: string): string
 
 function getIntentOnlyFallback(args: BashToolArgs, command: string): string {
   const displayName = typeof args.display_name === "string" ? args.display_name.trim() : "";
-  if (displayName && normalizeForComparison(displayName) !== normalizeForComparison(command)) {
+  if (displayName && !matchesCommand(displayName, command)) {
     return capitalize(displayName);
   }
 
@@ -112,7 +109,7 @@ function stripTrailingUsingCommand(intent: string, command: string): string {
 
   const prefix = match[1]?.trim() ?? "";
   const candidate = stripWrappingQuotes(match[2] ?? "");
-  if (normalizeForComparison(candidate) !== normalizeForComparison(command)) {
+  if (!matchesCommand(candidate, command)) {
     return intent;
   }
 
@@ -128,3 +125,8 @@ function stripWrappingQuotes(value: string): string {
 function normalizeForComparison(value: string): string {
   return value.trim().replace(/\s+/gu, " ").toLowerCase();
 }
+
+/** Whitespace- and case-insensitive equality so an intent that echoes the command is treated as redundant. */
+function matchesCommand(value: string, command: string): boolean {
+  return normalizeForComparison(value) === normalizeForComparison(command);
+}
diff --git a/src/browser/hooks/useChatTranscriptFullWidth.ts b/src/browser/hooks/useChatTranscriptFullWidth.ts
index 6bf92b850b..35691d0e7d 100644
--- a/src/browser/hooks/useChatTranscriptFullWidth.ts
+++ b/src/browser/hooks/useChatTranscriptFullWidth.ts
@@ -4,6 +4,19 @@ import { useAPI } from "@/browser/contexts/API";
 import { updatePersistedState, usePersistedState } from "@/browser/hooks/usePersistedState";
 import { CHAT_TRANSCRIPT_FULL_WIDTH_KEY } from "@/common/constants/storage";
 
+/**
+ * Mirror the chat-transcript full-width preference into local persisted state so
+ * other consumers (ChatPane mount, settings load) recover the last known value
+ * without waiting on the backend. Stores `true` when enabled, clears the slot
+ * otherwise to match the on-disk config shape.
+ */
+export function persistChatTranscriptFullWidth(enabled: boolean): void {
+  updatePersistedState<boolean | undefined>(
+    CHAT_TRANSCRIPT_FULL_WIDTH_KEY,
+    enabled ? true : undefined
+  );
+}
+
 /** Seeded from local cache to avoid a layout flash before the backend responds. */
 export function useChatTranscriptFullWidth(): boolean {
   const { api } = useAPI();
@@ -49,10 +62,7 @@ export function useChatTranscriptFullWidth(): boolean {
 
       chatTranscriptFullWidthRef.current = enabled;
       backendPersistedValueRef.current = enabled;
-      updatePersistedState<boolean | undefined>(
-        CHAT_TRANSCRIPT_FULL_WIDTH_KEY,
-        enabled ? true : undefined
-      );
+      persistChatTranscriptFullWidth(enabled);
     };
 
     const refresh = () => {
diff --git a/src/browser/utils/additionalSystemContextStore.ts b/src/browser/utils/additionalSystemContextStore.ts
index 500b580fc0..3866dd3338 100644
--- a/src/browser/utils/additionalSystemContextStore.ts
+++ b/src/browser/utils/additionalSystemContextStore.ts
@@ -15,10 +15,27 @@ const subscribersByWorkspace = new Map<string, Set<() => void>>();
 const focusListenersByWorkspace = new Map<string, Set<() => void>>();
 
 function getSubscribers(workspaceId: string): Set<() => void> {
-  const existing = subscribersByWorkspace.get(workspaceId);
+  return getOrCreateListenerSet(subscribersByWorkspace, workspaceId);
+}
+
+function getFocusListeners(workspaceId: string): Set<() => void> {
+  return getOrCreateListenerSet(focusListenersByWorkspace, workspaceId);
+}
+
+// Shared lazy-init for the per-workspace listener Maps used by the
+// subscriber and focus channels. Returns the existing Set when present, or
+// inserts a fresh Set keyed by workspaceId so callers can unconditionally
+// `.add()` without re-checking Map presence (which also avoids the
+// TypeScript narrowing dance `subscribeAdditionalSystemContextFocus`
+// previously needed to satisfy the closure capture).
+function getOrCreateListenerSet(
+  map: Map<string, Set<() => void>>,
+  workspaceId: string
+): Set<() => void> {
+  const existing = map.get(workspaceId);
   if (existing) return existing;
   const created = new Set<() => void>();
-  subscribersByWorkspace.set(workspaceId, created);
+  map.set(workspaceId, created);
   return created;
 }
 
@@ -167,7 +184,7 @@ export function queueAdditionalSystemContextSave(
  * soon as it mounts, and the focus request remains visible because we replay
  * it with a small generation counter.
  */
-let pendingFocusGeneration = new Map<string, number>();
+const pendingFocusGeneration = new Map<string, number>();
 
 export function requestAdditionalSystemContextFocus(workspaceId: string): void {
   const next = (pendingFocusGeneration.get(workspaceId) ?? 0) + 1;
@@ -181,16 +198,11 @@ export function subscribeAdditionalSystemContextFocus(
   workspaceId: string,
   callback: () => void
 ): () => void {
-  let listeners = focusListenersByWorkspace.get(workspaceId);
-  if (!listeners) {
-    listeners = new Set();
-    focusListenersByWorkspace.set(workspaceId, listeners);
-  }
-  const target = listeners;
-  target.add(callback);
+  const listeners = getFocusListeners(workspaceId);
+  listeners.add(callback);
   return () => {
-    target.delete(callback);
-    if (target.size === 0) {
+    listeners.delete(callback);
+    if (listeners.size === 0) {
       focusListenersByWorkspace.delete(workspaceId);
     }
   };
@@ -200,11 +212,6 @@ export function getAdditionalSystemContextFocusGeneration(workspaceId: string):
   return pendingFocusGeneration.get(workspaceId) ?? 0;
 }
 
-/** Test-only: reset focus generation counters between scenarios. */
-export function __resetAdditionalSystemContextFocusForTests(): void {
-  pendingFocusGeneration = new Map();
-}
-
 export function useAdditionalSystemContextHydrated(workspaceId: string): boolean {
   return useSyncExternalStore(
     (callback) => subscribeAdditionalSystemContext(workspaceId, callback),
diff --git a/src/browser/utils/browserLocalhostProxyTemplate.ts b/src/browser/utils/browserLocalhostProxyTemplate.ts
index 29c9f84bdd..1d3dd240c0 100644
--- a/src/browser/utils/browserLocalhostProxyTemplate.ts
+++ b/src/browser/utils/browserLocalhostProxyTemplate.ts
@@ -1,3 +1,5 @@
+import { isHttpProtocol } from "@/common/utils/localhostProxyUrl";
+
 const CODER_PORT_PREFIX_PATTERN = /^\d+$/;
 
 interface ResolveBrowserLocalhostProxyTemplateOptions {
@@ -12,10 +14,6 @@ function normalizeInjectedTemplate(injectedTemplate?: string | null): string | n
   return normalizedTemplate && normalizedTemplate.length > 0 ? normalizedTemplate : null;
 }
 
-function isHttpProtocol(protocol: string): protocol is "http:" | "https:" {
-  return protocol === "http:" || protocol === "https:";
-}
-
 function deriveCoderTemplateFromBrowserHost(
   browserProtocol?: string | null,
   browserHostname?: string | null,
diff --git a/src/browser/utils/highlighting/highlightDiffChunk.ts b/src/browser/utils/highlighting/highlightDiffChunk.ts
index bdcfdb279b..e31c3bcfe2 100644
--- a/src/browser/utils/highlighting/highlightDiffChunk.ts
+++ b/src/browser/utils/highlighting/highlightDiffChunk.ts
@@ -45,18 +45,11 @@ export async function highlightDiffChunk(
   language: string,
   themeMode: ThemeMode = "dark"
 ): Promise<HighlightedChunk> {
-  // Fast path: no highlighting for text files
+  // Fast path: no highlighting for text files. `usedFallback: false` because
+  // plain-text rendering is the intentional choice for these languages, not a
+  // recovery path from a failed highlight attempt.
   if (language === "text" || language === "plaintext") {
-    return {
-      type: chunk.type,
-      lines: chunk.lines.map((line, i) => ({
-        html: escapeHtml(line),
-        oldLineNumber: chunk.oldLineNumbers[i],
-        newLineNumber: chunk.newLineNumbers[i],
-        originalIndex: chunk.startIndex + i,
-      })),
-      usedFallback: false,
-    };
+    return createPlainTextChunk(chunk, false);
   }
 
   // Enforce size limit for performance
@@ -64,7 +57,7 @@ export async function highlightDiffChunk(
   const sizeBytes =
     chunk.lines.reduce((total, line) => total + line.length, 0) + chunk.lines.length - 1;
   if (sizeBytes > MAX_DIFF_SIZE_BYTES) {
-    return createFallbackChunk(chunk);
+    return createPlainTextChunk(chunk, true);
   }
 
   const code = chunk.lines.join("\n");
@@ -80,7 +73,7 @@ export async function highlightDiffChunk(
     // Validate output (detect broken highlighting)
     if (lines.length !== chunk.lines.length) {
       // Mismatch - highlighting broke the structure
-      return createFallbackChunk(chunk);
+      return createPlainTextChunk(chunk, true);
     }
 
     // Check if any non-empty line became empty after extraction (indicates malformed HTML)
@@ -89,7 +82,7 @@ export async function highlightDiffChunk(
       (extractedHtml, i) => extractedHtml.length === 0 && chunk.lines[i].length > 0
     );
     if (hasEmptyExtraction) {
-      return createFallbackChunk(chunk);
+      return createPlainTextChunk(chunk, true);
     }
 
     return {
@@ -104,14 +97,19 @@ export async function highlightDiffChunk(
     };
   } catch (error) {
     console.warn(`Syntax highlighting failed for language ${language}:`, error);
-    return createFallbackChunk(chunk);
+    return createPlainTextChunk(chunk, true);
   }
 }
 
 /**
- * Create plain text fallback for a chunk
+ * Build a plain-text `HighlightedChunk` for `chunk`. Used both by the
+ * text/plaintext fast path (`usedFallback: false`) and as the recovery path
+ * when highlighting fails or the diff exceeds the size budget
+ * (`usedFallback: true`). The line mapping is identical in either case; the
+ * boolean is preserved verbatim so consumers can distinguish "intentional
+ * plain text" from "highlighting fell back".
  */
-function createFallbackChunk(chunk: DiffChunk): HighlightedChunk {
+function createPlainTextChunk(chunk: DiffChunk, usedFallback: boolean): HighlightedChunk {
   return {
     type: chunk.type,
     lines: chunk.lines.map((line, i) => ({
@@ -120,7 +118,7 @@ function createFallbackChunk(chunk: DiffChunk): HighlightedChunk {
       newLineNumber: chunk.newLineNumbers[i],
       originalIndex: chunk.startIndex + i,
     })),
-    usedFallback: true,
+    usedFallback,
   };
 }
 
diff --git a/src/browser/utils/messages/recency.ts b/src/browser/utils/messages/recency.ts
index 1b416594f9..93a0ad993d 100644
--- a/src/browser/utils/messages/recency.ts
+++ b/src/browser/utils/messages/recency.ts
@@ -16,15 +16,20 @@ export function computeRecencyTimestamp(
   createdAt?: string,
   unarchivedAt?: string
 ): number | null {
-  let createdTimestamp: number | undefined;
-  if (createdAt) {
-    const parsed = new Date(createdAt).getTime();
-    createdTimestamp = !isNaN(parsed) ? parsed : undefined;
-  }
-  let unarchivedTimestamp: number | undefined;
-  if (unarchivedAt) {
-    const parsed = new Date(unarchivedAt).getTime();
-    unarchivedTimestamp = !isNaN(parsed) ? parsed : undefined;
-  }
-  return computeRecencyFromMessages(messages, createdTimestamp, unarchivedTimestamp);
+  return computeRecencyFromMessages(
+    messages,
+    parseOptionalIsoTimestamp(createdAt),
+    parseOptionalIsoTimestamp(unarchivedAt)
+  );
+}
+
+// Both `createdAt` and `unarchivedAt` arrive as optional ISO strings and feed
+// the same numeric-timestamp slot in `computeRecencyFromMessages`. Centralizing
+// the parse keeps the invalid-date guard (NaN → undefined) consistent across
+// inputs; an unparseable string is treated the same as a missing one so it
+// can't poison the max() in the underlying recency calculation.
+function parseOptionalIsoTimestamp(value: string | undefined): number | undefined {
+  if (!value) return undefined;
+  const parsed = new Date(value).getTime();
+  return !isNaN(parsed) ? parsed : undefined;
 }
diff --git a/src/browser/utils/powerMode/PowerModeEngine.ts b/src/browser/utils/powerMode/PowerModeEngine.ts
index e1f4767607..b527bfb8de 100644
--- a/src/browser/utils/powerMode/PowerModeEngine.ts
+++ b/src/browser/utils/powerMode/PowerModeEngine.ts
@@ -1,3 +1,5 @@
+import { clamp } from "@/common/utils/clamp";
+
 interface Particle {
   x: number;
   y: number;
@@ -69,7 +71,7 @@ export class PowerModeEngine {
   }
 
   burst(x: number, y: number, intensity = 1, options?: BurstOptions): void {
-    const normalizedIntensity = Math.max(1, Math.min(12, Math.floor(intensity)));
+    const normalizedIntensity = clamp(Math.floor(intensity), 1, 12);
     const kind = options?.kind ?? "insert";
 
     this.maybeShake(normalizedIntensity);
@@ -167,7 +169,7 @@ export class PowerModeEngine {
 
     const lastFrameTimeMs = (this.lastFrameTimeMs ??= nowMs);
 
-    const dtMs = Math.min(34, Math.max(0, nowMs - lastFrameTimeMs));
+    const dtMs = clamp(nowMs - lastFrameTimeMs, 0, 34);
     this.lastFrameTimeMs = nowMs;
 
     this.step(dtMs);
@@ -213,7 +215,7 @@ export class PowerModeEngine {
     ctx.globalCompositeOperation = "lighter";
 
     for (const p of this.particles) {
-      const alpha = Math.max(0, Math.min(1, p.lifeMs / p.ttlMs));
+      const alpha = clamp(p.lifeMs / p.ttlMs, 0, 1);
       ctx.globalAlpha = alpha;
       ctx.fillStyle = p.color;
       ctx.fillRect(p.x, p.y, p.size, p.size);
@@ -445,7 +447,7 @@ export class PowerModeEngine {
     this.tryResumeAudioContext(ctx);
 
     const t0 = ctx.currentTime;
-    const intensityT = (Math.max(1, Math.min(12, intensity)) - 1) / 11;
+    const intensityT = (clamp(intensity, 1, 12) - 1) / 11;
 
     const noiseSource = ctx.createBufferSource();
     noiseSource.buffer = noiseBuffer;
@@ -506,7 +508,7 @@ export class PowerModeEngine {
     this.tryResumeAudioContext(ctx);
 
     const t0 = ctx.currentTime;
-    const intensityT = (Math.max(1, Math.min(12, intensity)) - 1) / 11;
+    const intensityT = (clamp(intensity, 1, 12) - 1) / 11;
 
     const noiseSource = ctx.createBufferSource();
     noiseSource.buffer = noiseBuffer;
diff --git a/src/browser/utils/slashCommands/experimentVisibility.ts b/src/browser/utils/slashCommands/experimentVisibility.ts
index 1313946fd9..b1b9ff5321 100644
--- a/src/browser/utils/slashCommands/experimentVisibility.ts
+++ b/src/browser/utils/slashCommands/experimentVisibility.ts
@@ -15,3 +15,17 @@ export function resolveSlashCommandExperimentValue(
       return undefined;
   }
 }
+
+/**
+ * Build the `isExperimentEnabled` predicate consumed by slash-command
+ * discovery surfaces (suggestions, ghost hints, command palette). Each
+ * surface previously inlined the same `(experimentId) =>
+ * resolveSlashCommandExperimentValue(experimentId, snapshot)` lambda; this
+ * helper keeps the resolver wiring in one place so callsites only describe
+ * the snapshot they observe.
+ */
+export function createSlashCommandExperimentResolver(
+  snapshot: SlashCommandExperimentSnapshot
+): (experimentId: ExperimentId) => boolean | undefined {
+  return (experimentId) => resolveSlashCommandExperimentValue(experimentId, snapshot);
+}
diff --git a/src/cli/run.ts b/src/cli/run.ts
index e4371d0354..f672341a3d 100644
--- a/src/cli/run.ts
+++ b/src/cli/run.ts
@@ -69,10 +69,9 @@ import assert from "../common/utils/assert";
 import type { LanguageModelV2Usage } from "@ai-sdk/provider";
 import { log, type LogLevel } from "../node/services/log";
 import chalk from "chalk";
-import type { InitLogger, WorkspaceInitResult } from "../node/runtime/Runtime";
+import type { InitLogger, Runtime, WorkspaceInitResult } from "../node/runtime/Runtime";
 import { DockerRuntime } from "../node/runtime/DockerRuntime";
 import { createRuntime, runFullInit } from "../node/runtime/runtimeFactory";
-import type { Runtime } from "../node/runtime/Runtime";
 import { execSync } from "child_process";
 import { getParseOptions } from "./argv";
 import { EXPERIMENT_IDS } from "../common/constants/experiments";
@@ -165,7 +164,7 @@ function parseGoalBudgetFlag(value: string | undefined): number | null | undefin
   const parsed = parseGoalBudgetInputCents(value);
   if (parsed === undefined) {
     throw new Error(
-      'Invalid --goal-budget "' + value + '". Expected dollars like 5, $5.00, or cents like 500c'
+      `Invalid --goal-budget "${value}". Expected dollars like 5, $5.00, or cents like 500c`
     );
   }
   return parsed;
@@ -175,7 +174,7 @@ function parseGoalTurnsFlag(value: string | undefined): number | undefined {
   if (value == null) return undefined;
   const parsed = parseGoalTurnCapInput(value);
   if (parsed == null) {
-    throw new Error('Invalid --goal-turns "' + value + '". Expected a positive integer');
+    throw new Error(`Invalid --goal-turns "${value}". Expected a positive integer`);
   }
   return parsed;
 }
@@ -755,6 +754,19 @@ async function main(): Promise<number> {
 
   const experiments = buildExperimentsObject(opts.experiment);
 
+  // Tools disabled for `mux run`: either no-op or require UI interaction in headless mode.
+  // - ask_user_question: waits for a desktop/mobile answer UI; headless `mux run` cannot answer it
+  // - status_set: backend no-op, status indicator only visible in desktop UI
+  // - todo_write/todo_read: TODO list only visible in desktop UI
+  // - notify: sends OS notifications via Electron, silently swallowed in CLI
+  const CLI_DISABLED_TOOL_NAMES = [
+    "ask_user_question",
+    "status_set",
+    "todo_write",
+    "todo_read",
+    "notify",
+  ] as const;
+
   const buildSendOptions = (cliMode: CLIMode): SendMessageOptions => ({
     model,
     thinkingLevel,
@@ -764,18 +776,10 @@ async function main(): Promise<number> {
       ...(opts.use1m && { anthropic: { use1MContext: true } }),
       ...(opts.serviceTier != null && { openai: { serviceTier: opts.serviceTier } }),
     },
-    // Disable UI-only tools that either no-op or require UI interaction in CLI mode:
-    // - ask_user_question: waits for a desktop/mobile answer UI; headless `mux run` cannot answer it
-    // - status_set: backend no-op, status indicator only visible in desktop UI
-    // - todo_write/todo_read: TODO list only visible in desktop UI
-    // - notify: sends OS notifications via Electron, silently swallowed in CLI
-    toolPolicy: [
-      { regex_match: "ask_user_question", action: "disable" as const },
-      { regex_match: "status_set", action: "disable" as const },
-      { regex_match: "todo_write", action: "disable" as const },
-      { regex_match: "todo_read", action: "disable" as const },
-      { regex_match: "notify", action: "disable" as const },
-    ],
+    toolPolicy: CLI_DISABLED_TOOL_NAMES.map((name) => ({
+      regex_match: name,
+      action: "disable" as const,
+    })),
     // Plan agent instructions are handled by the backend (has access to plan file path)
   });
 
diff --git a/src/common/orpc/types.ts b/src/common/orpc/types.ts
index d2166ca52b..a077e2f8c3 100644
--- a/src/common/orpc/types.ts
+++ b/src/common/orpc/types.ts
@@ -28,6 +28,13 @@ import type {
 
 export type BranchListResult = z.infer<typeof schemas.BranchListResultSchema>;
 export type SendMessageOptions = z.infer<typeof schemas.SendMessageOptionsSchema>;
+/**
+ * Canonical sub-types derived from {@link SendMessageOptions}. Kept in this
+ * shared module so the browser ChatInput, the node MessageQueue, and the
+ * AgentSession dispatcher all reach for the same alias instead of each
+ * privately re-deriving `NonNullable<SendMessageOptions["..."]>`.
+ */
+export type GoalInterventionPolicy = NonNullable<SendMessageOptions["goalInterventionPolicy"]>;
 
 // Provider types (single source of truth - derived from schemas)
 export type AWSCredentialStatus = z.infer<typeof schemas.AWSCredentialStatusSchema>;
diff --git a/src/common/utils/ai/streamChunks.ts b/src/common/utils/ai/streamChunks.ts
index 3648e8506c..eb4c8b9dc7 100644
--- a/src/common/utils/ai/streamChunks.ts
+++ b/src/common/utils/ai/streamChunks.ts
@@ -1,3 +1,11 @@
+/**
+ * Field priority for AI SDK v5 text-delta payloads emitted by `fullStream`
+ * parts and `streamText()` `onChunk` callbacks. Providers/SDKs normalize the
+ * delta into one of these keys; `text` is preferred when present and the
+ * older `delta` / `textDelta` aliases are fallbacks.
+ */
+export const TEXT_OUTPUT_DELTA_FIELDS = ["text", "delta", "textDelta"] as const;
+
 export function extractChunkDeltaText(
   chunk: Record<string, unknown>,
   fieldPriority: readonly string[]
diff --git a/src/common/utils/env.ts b/src/common/utils/env.ts
index 879b344e29..61289e0421 100644
--- a/src/common/utils/env.ts
+++ b/src/common/utils/env.ts
@@ -2,6 +2,15 @@
  * Environment variable parsing utilities
  */
 
+/**
+ * Lowercased env values treated as boolean true ("1" / "true" / "yes",
+ * case-insensitive). Shared by parseBoolEnv and parseDebugUpdater so both
+ * affirmative checks stay in sync.
+ */
+function isAffirmativeEnvValue(normalized: string): boolean {
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+
 /**
  * Parse environment variable as boolean
  * Accepts: "1", "true", "TRUE", "yes", "YES" as true
@@ -10,7 +19,7 @@
 export function parseBoolEnv(value: string | undefined): boolean {
   if (!value) return false;
   const normalized = value.toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes";
+  return isAffirmativeEnvValue(normalized);
 }
 
 /**
@@ -48,7 +57,7 @@ export function parseDebugUpdater(
   }
 
   const normalized = value.toLowerCase();
-  if (normalized === "1" || normalized === "true" || normalized === "yes") {
+  if (isAffirmativeEnvValue(normalized)) {
     result.enabled = true;
   } else {
     // Not a bool, treat as version string
diff --git a/src/common/utils/localhostProxyUrl.ts b/src/common/utils/localhostProxyUrl.ts
index fcc82904ba..8ee583d10d 100644
--- a/src/common/utils/localhostProxyUrl.ts
+++ b/src/common/utils/localhostProxyUrl.ts
@@ -1,4 +1,8 @@
-export type LocalhostLoopbackHost = "localhost" | "127.0.0.1" | "0.0.0.0" | "::1";
+// Single source of truth for loopback host literals so the runtime guard set
+// (LOOPBACK_HOST_SET) and the LocalhostLoopbackHost union can't drift apart.
+const LOOPBACK_HOSTS = ["localhost", "127.0.0.1", "0.0.0.0", "::1"] as const;
+
+export type LocalhostLoopbackHost = (typeof LOOPBACK_HOSTS)[number];
 
 export interface NormalizeLocalhostProxyUrlOptions {
   url: string;
@@ -8,7 +12,7 @@ export interface NormalizeLocalhostProxyUrlOptions {
 
 const PORT_TEMPLATE_VARIABLE = "{{port}}";
 const HOST_TEMPLATE_VARIABLE = "{{host}}";
-const LOOPBACK_HOSTS: ReadonlySet<string> = new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1"]);
+const LOOPBACK_HOST_SET: ReadonlySet<string> = new Set(LOOPBACK_HOSTS);
 
 function stripIpv6Brackets(hostname: string): string {
   if (hostname.startsWith("[") && hostname.endsWith("]")) {
@@ -19,10 +23,13 @@ function stripIpv6Brackets(hostname: string): string {
 
 function isLoopbackHost(hostname: string): hostname is LocalhostLoopbackHost {
   const normalizedHost = stripIpv6Brackets(hostname.trim().toLowerCase());
-  return LOOPBACK_HOSTS.has(normalizedHost);
+  return LOOPBACK_HOST_SET.has(normalizedHost);
 }
 
-function isHttpProtocol(protocol: string): protocol is "http:" | "https:" {
+// Exported so browser-mode proxy template resolution can share a single
+// definition instead of redeclaring the identical guard (see
+// browserLocalhostProxyTemplate.ts).
+export function isHttpProtocol(protocol: string): protocol is "http:" | "https:" {
   return protocol === "http:" || protocol === "https:";
 }
 
diff --git a/src/common/utils/review/assistedReview.test.ts b/src/common/utils/review/assistedReview.test.ts
index 6f827650a3..e094310c0f 100644
--- a/src/common/utils/review/assistedReview.test.ts
+++ b/src/common/utils/review/assistedReview.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import type { DiffHunk } from "@/common/types/review";
 import {
+  filterDismissedAssistedHunks,
   findAssistedMatch,
   formatAssistedFilter,
   hunkMatchesAssisted,
@@ -114,3 +115,28 @@ describe("formatAssistedFilter", () => {
     expect(formatAssistedFilter({ path: "a", range: { start: 5, end: 9 } })).toBe("a:5-9");
   });
 });
+
+describe("filterDismissedAssistedHunks", () => {
+  it("returns the input array reference unchanged when no keys are dismissed", () => {
+    // Identity preservation is important: downstream useMemo consumers
+    // depend on a stable reference when nothing has changed.
+    const raw = [{ path: "src/foo.ts" }, { path: "src/bar.ts", range: { start: 1, end: 2 } }];
+    expect(filterDismissedAssistedHunks(raw, [])).toBe(raw);
+  });
+
+  it("drops entries whose formatted key matches the dismissed list", () => {
+    const raw = [
+      { path: "src/foo.ts" },
+      { path: "src/bar.ts", range: { start: 1, end: 2 } },
+      { path: "src/baz.ts", range: { start: 5, end: 5 } },
+    ];
+    expect(filterDismissedAssistedHunks(raw, ["src/bar.ts:1-2", "src/baz.ts:5"])).toEqual([
+      { path: "src/foo.ts" },
+    ]);
+  });
+
+  it("ignores dismissed keys that don't match any current entry", () => {
+    const raw = [{ path: "src/foo.ts" }];
+    expect(filterDismissedAssistedHunks(raw, ["src/gone.ts:10"])).toEqual(raw);
+  });
+});
diff --git a/src/common/utils/review/assistedReview.ts b/src/common/utils/review/assistedReview.ts
index 2fcc3396c7..79c8aa0c91 100644
--- a/src/common/utils/review/assistedReview.ts
+++ b/src/common/utils/review/assistedReview.ts
@@ -108,3 +108,22 @@ export function formatAssistedFilter(hunk: AssistedReviewHunk): string {
   const { start, end } = hunk.range;
   return start === end ? `${hunk.path}:${start}` : `${hunk.path}:${start}-${end}`;
 }
+
+/**
+ * Filter the agent's raw assisted set against a user-side dismissed list
+ * keyed by {@link formatAssistedFilter}. Returns the input array reference
+ * unchanged when `dismissedKeys` is empty so memoized consumers retain a
+ * stable identity (no spurious downstream re-derivations).
+ *
+ * The dismissed list is "quiet" / user-only — we never mutate the agent's
+ * pins, so dismissed entries naturally fall off once the agent clears or
+ * replaces its set.
+ */
+export function filterDismissedAssistedHunks(
+  rawAssistedHunks: readonly AssistedReviewHunk[],
+  dismissedKeys: readonly string[]
+): readonly AssistedReviewHunk[] {
+  if (dismissedKeys.length === 0) return rawAssistedHunks;
+  const dismissed = new Set(dismissedKeys);
+  return rawAssistedHunks.filter((entry) => !dismissed.has(formatAssistedFilter(entry)));
+}
diff --git a/src/common/utils/thinking/policy.ts b/src/common/utils/thinking/policy.ts
index 88bac6388f..4ef866b2b5 100644
--- a/src/common/utils/thinking/policy.ts
+++ b/src/common/utils/thinking/policy.ts
@@ -124,6 +124,17 @@ export function getThinkingPolicyForModel(modelString: string): ThinkingPolicy {
   return ["off", "low", "medium", "high"];
 }
 
+/**
+ * Canonical ordering index for a level (off=0 … max=5).
+ *
+ * `enforceThinkingPolicy` and `resolveThinkingInput` both rank levels by their position
+ * in `THINKING_LEVELS`; route every comparison through this helper so the ordering lives
+ * in one place. Pure dedup — `THINKING_LEVELS.indexOf` is unchanged.
+ */
+function thinkingLevelIndex(level: ThinkingLevel): number {
+  return THINKING_LEVELS.indexOf(level);
+}
+
 /**
  * Enforce thinking policy by clamping requested level to allowed set.
  *
@@ -144,23 +155,23 @@ export function enforceThinkingPolicy(
   }
 
   const orderedAllowed = [...allowed].sort(
-    (left, right) => THINKING_LEVELS.indexOf(left) - THINKING_LEVELS.indexOf(right)
+    (left, right) => thinkingLevelIndex(left) - thinkingLevelIndex(right)
   );
   const minAllowed = orderedAllowed[0] ?? "off";
   const maxAllowed = orderedAllowed[orderedAllowed.length - 1] ?? minAllowed;
-  const requestedIndex = THINKING_LEVELS.indexOf(requested);
+  const requestedIndex = thinkingLevelIndex(requested);
 
-  if (requestedIndex <= THINKING_LEVELS.indexOf(minAllowed)) {
+  if (requestedIndex <= thinkingLevelIndex(minAllowed)) {
     return minAllowed;
   }
 
-  if (requestedIndex >= THINKING_LEVELS.indexOf(maxAllowed)) {
+  if (requestedIndex >= thinkingLevelIndex(maxAllowed)) {
     return maxAllowed;
   }
 
   const closest = orderedAllowed.reduce((nearest, level) => {
-    const nearestIndex = THINKING_LEVELS.indexOf(nearest);
-    const levelIndex = THINKING_LEVELS.indexOf(level);
+    const nearestIndex = thinkingLevelIndex(nearest);
+    const levelIndex = thinkingLevelIndex(level);
     return Math.abs(levelIndex - requestedIndex) < Math.abs(nearestIndex - requestedIndex)
       ? level
       : nearest;
@@ -186,9 +197,7 @@ export function resolveThinkingInput(
 
   // Numeric: index into the model's allowed levels (sorted lowest → highest)
   const policy = getThinkingPolicyForModel(modelString);
-  const sorted = [...policy].sort(
-    (a, b) => THINKING_LEVELS.indexOf(a) - THINKING_LEVELS.indexOf(b)
-  );
+  const sorted = [...policy].sort((a, b) => thinkingLevelIndex(a) - thinkingLevelIndex(b));
   const clamped = Math.max(0, Math.min(input, sorted.length - 1));
   return sorted[clamped] ?? sorted[0] ?? "off";
 }
diff --git a/src/node/acp/agent.ts b/src/node/acp/agent.ts
index 982d22ab31..4b01d1d74f 100644
--- a/src/node/acp/agent.ts
+++ b/src/node/acp/agent.ts
@@ -305,8 +305,7 @@ export class MuxAgent implements Agent {
       // repo.  Worktree/SSH runtimes require a trunk branch for workspace creation.
       let trunkBranch = meta.trunkBranch;
       if (trunkBranch == null || trunkBranch.trim().length === 0) {
-        const branchInfo = await this.server.client.projects.listBranches({ projectPath });
-        trunkBranch = branchInfo.recommendedTrunk ?? DEFAULT_TRUNK_BRANCH;
+        trunkBranch = await this.resolveRecommendedTrunkBranch(projectPath);
       }
 
       const createResult = await this.server.client.workspace.create({
@@ -624,6 +623,18 @@ export class MuxAgent implements Agent {
     return Promise.resolve({});
   }
 
+  /**
+   * Resolve the trunk branch for a project from backend branch discovery,
+   * falling back to DEFAULT_TRUNK_BRANCH when none is recommended. The ACP
+   * `session/new` path and the `/new` slash command both create workspaces
+   * from a bare project path and previously inlined this same two-step
+   * lookup; sharing it keeps the trunk fallback in one place.
+   */
+  private async resolveRecommendedTrunkBranch(projectPath: string): Promise<string> {
+    const branchInfo = await this.server.client.projects.listBranches({ projectPath });
+    return branchInfo.recommendedTrunk ?? DEFAULT_TRUNK_BRANCH;
+  }
+
   private async sendWorkspaceMessageAndAwaitTurn(args: {
     sessionId: string;
     workspaceId: string;
@@ -886,10 +897,7 @@ export class MuxAgent implements Agent {
 
         // Resolve trunk from project defaults — /new no longer accepts overrides
         // (it now mirrors /fork's seamless flow).
-        const branchInfo = await this.server.client.projects.listBranches({
-          projectPath: workspaceInfo.projectPath,
-        });
-        const trunkBranch = branchInfo.recommendedTrunk ?? DEFAULT_TRUNK_BRANCH;
+        const trunkBranch = await this.resolveRecommendedTrunkBranch(workspaceInfo.projectPath);
 
         const hasStartMessage =
           parsedCommand.startMessage != null && parsedCommand.startMessage.trim().length > 0;
diff --git a/src/node/runtime/SSHRuntime.ts b/src/node/runtime/SSHRuntime.ts
index 85f787aec6..065a683987 100644
--- a/src/node/runtime/SSHRuntime.ts
+++ b/src/node/runtime/SSHRuntime.ts
@@ -93,32 +93,18 @@ const BASE_REPO_PROMISOR_CONFIG_KEYS = [
 ] as const;
 const BASE_REPO_FRAGMENTED_PACK_THRESHOLD = 25;
 const PROJECT_SYNC_MAX_ATTEMPTS = 3;
-const PROJECT_SYNC_RETRYABLE_ERRORS = [
-  "pack-objects died",
-  "Connection reset",
-  "Connection closed",
-  "Broken pipe",
-  "EPIPE",
-  "Command killed by signal",
-  // Receive-pack thin-pack resolution failures. These happen when the bare
-  // base repo routes a small push through `unpack-objects` (because object
-  // count < `transfer.unpackLimit`, default 100) and the thin pack references
-  // delta bases that unpack-objects cannot resolve, or when the on-disk pack
-  // store is missing the assumed-present base objects (e.g. a `.pack` with no
-  // `.idx`). The retry path runs `repairBaseRepoForSync`, which sets
-  // `receive.unpackLimit=1` (forcing index-pack with `--fix-thin`) and runs
-  // gc, and the next push is force-promoted to `--no-thin` so the pack is
-  // self-contained. See `isUnresolvedDeltaPushFailure`.
-  "unresolved deltas",
-  "unpacker error",
-  "unpack-objects abnormal exit",
-  "remote unpack failed",
-] as const;
-
 /**
- * Patterns matching the receive-pack failure described above. Detected
- * separately from generic retryable errors so the retry path can opt the next
- * push into `--no-thin` instead of just rerunning the same thin push.
+ * Receive-pack thin-pack resolution failures. These happen when the bare base
+ * repo routes a small push through `unpack-objects` (because object count <
+ * `transfer.unpackLimit`, default 100) and the thin pack references delta
+ * bases that unpack-objects cannot resolve, or when the on-disk pack store is
+ * missing the assumed-present base objects (e.g. a `.pack` with no `.idx`).
+ *
+ * Tracked as a distinct sub-class of retryable errors so the retry path can
+ * opt the next push into `--no-thin` instead of just rerunning the same thin
+ * push. The retry path also runs `repairBaseRepoForSync`, which sets
+ * `receive.unpackLimit=1` (forcing index-pack with `--fix-thin`) and runs gc.
+ * See `isUnresolvedDeltaPushFailure`.
  */
 const UNRESOLVED_DELTA_PUSH_PATTERNS = [
   "unresolved deltas",
@@ -127,6 +113,17 @@ const UNRESOLVED_DELTA_PUSH_PATTERNS = [
   "remote unpack failed",
 ] as const;
 
+const PROJECT_SYNC_RETRYABLE_ERRORS = [
+  "pack-objects died",
+  "Connection reset",
+  "Connection closed",
+  "Broken pipe",
+  "EPIPE",
+  "Command killed by signal",
+  // Receive-pack thin-pack resolution failures — see `UNRESOLVED_DELTA_PUSH_PATTERNS`.
+  ...UNRESOLVED_DELTA_PUSH_PATTERNS,
+] as const;
+
 function isUnresolvedDeltaPushFailure(errorMsg: string): boolean {
   return UNRESOLVED_DELTA_PUSH_PATTERNS.some((pattern) => errorMsg.includes(pattern));
 }
diff --git a/src/node/services/agentSession.ts b/src/node/services/agentSession.ts
index 8e36ccfde0..0505c13684 100644
--- a/src/node/services/agentSession.ts
+++ b/src/node/services/agentSession.ts
@@ -19,6 +19,7 @@ import { computePriorHistoryFingerprint } from "@/common/orpc/onChatCursorFinger
 import type {
   WorkspaceChatMessage,
   SendMessageOptions,
+  GoalInterventionPolicy,
   FilePart,
   DeleteMessage,
   OnChatMode,
@@ -177,8 +178,6 @@ interface CompactionRequestMetadata {
   };
 }
 
-type GoalInterventionPolicy = NonNullable<SendMessageOptions["goalInterventionPolicy"]>;
-
 interface AutoRetryResumeRequest {
   // Same-session auto-retry must preserve the full normalized request because
   // ACP correlation/delegation lives in transient send options that are
@@ -219,6 +218,35 @@ function coerceGoalSyntheticMessageKind(value: unknown): GoalSyntheticMessageKin
   return undefined;
 }
 
+/**
+ * Last non-empty text part, trimmed and length-capped; falls back to a constant.
+ *
+ * Pure helper used by the silent-continuation auto-complete hook to synthesize
+ * a completion summary when a `goal_continuation` turn ends with text only and
+ * no `complete_goal` tool call. Kept as a free function (not a method) because
+ * it depends only on its input — matches the existing helper style above and
+ * makes the no-`this` contract obvious to readers.
+ */
+function synthesizeSilentContinuationSummary(parts: StreamEndEvent["parts"]): string {
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    const part = parts[index];
+    if (part.type !== "text") {
+      continue;
+    }
+    const trimmed = part.text.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    if (trimmed.length <= SILENT_CONTINUATION_COMPLETION_SUMMARY_MAX_LENGTH) {
+      return trimmed;
+    }
+    // Reserve one character for the ellipsis so the persisted summary
+    // stays under the configured cap.
+    return `${trimmed.slice(0, SILENT_CONTINUATION_COMPLETION_SUMMARY_MAX_LENGTH - 1)}…`;
+  }
+  return SILENT_CONTINUATION_COMPLETION_SUMMARY_FALLBACK;
+}
+
 const MAX_CONSECUTIVE_AGENT_SWITCHES = 3;
 
 const SAFE_AGENT_SWITCH_FALLBACK_CANDIDATES = ["exec", "plan"] as const;
@@ -3971,12 +3999,7 @@ export class AgentSession {
     // Include any synthetic snapshots that were persisted immediately before the task prompt.
     let seedStartIndex = firstPromptIndex;
     for (let i = firstPromptIndex - 1; i >= 0; i -= 1) {
-      const msg = messages[i];
-      const isSnapshot =
-        msg.role === "user" &&
-        msg.metadata?.synthetic === true &&
-        (msg.metadata?.fileAtMentionSnapshot ?? msg.metadata?.agentSkillSnapshot);
-      if (!isSnapshot) {
+      if (!this.isSyntheticSnapshotUserMessage(messages[i])) {
         break;
       }
       seedStartIndex = i;
@@ -4944,7 +4967,7 @@ export class AgentSession {
     if (payload.parts.some((part) => part.type === "dynamic-tool")) {
       return;
     }
-    const summary = this.synthesizeSilentContinuationSummary(payload.parts);
+    const summary = synthesizeSilentContinuationSummary(payload.parts);
     try {
       await this.workspaceGoalService.completeGoalFromSilentContinuation({
         workspaceId: this.workspaceId,
@@ -4962,27 +4985,6 @@ export class AgentSession {
     }
   }
 
-  /** Last non-empty text part, trimmed and length-capped; falls back to a constant. */
-  private synthesizeSilentContinuationSummary(parts: StreamEndEvent["parts"]): string {
-    for (let index = parts.length - 1; index >= 0; index -= 1) {
-      const part = parts[index];
-      if (part.type !== "text") {
-        continue;
-      }
-      const trimmed = part.text.trim();
-      if (trimmed.length === 0) {
-        continue;
-      }
-      if (trimmed.length <= SILENT_CONTINUATION_COMPLETION_SUMMARY_MAX_LENGTH) {
-        return trimmed;
-      }
-      // Reserve one character for the ellipsis so the persisted summary
-      // stays under the configured cap.
-      return `${trimmed.slice(0, SILENT_CONTINUATION_COMPLETION_SUMMARY_MAX_LENGTH - 1)}…`;
-    }
-    return SILENT_CONTINUATION_COMPLETION_SUMMARY_FALLBACK;
-  }
-
   /** Extract a successful switch_agent tool result from stream-end parts (latest wins). */
   private extractSwitchAgentResult(payload: StreamEndEvent): SwitchAgentResult | undefined {
     for (let index = payload.parts.length - 1; index >= 0; index -= 1) {
diff --git a/src/node/services/agentSkills/agentSkillsService.test.ts b/src/node/services/agentSkills/agentSkillsService.test.ts
index a70fa56ec1..94cf8b0200 100644
--- a/src/node/services/agentSkills/agentSkillsService.test.ts
+++ b/src/node/services/agentSkills/agentSkillsService.test.ts
@@ -201,6 +201,22 @@ class RemotePathMappedRuntime extends RemoteRuntime {
   }
 }
 
+/**
+ * Built-in skill names exposed by `discoverAgentSkills` /
+ * `discoverAgentSkillsDiagnostics` in this repo. Centralized so adding (or
+ * removing) a built-in only requires updating one list instead of every
+ * assertion that enumerates the full set. `orchestrate` is unadvertised but
+ * still discoverable, so it appears here for the same reason it appears in
+ * the discovery output.
+ */
+const BUILT_IN_SKILL_NAMES = [
+  "imagegen",
+  "init",
+  "mux-diagram",
+  "mux-docs",
+  "orchestrate",
+] as const;
+
 describe("agentSkillsService", () => {
   test("getDefaultAgentSkillsRoots derives global root from runtime mux home", () => {
     class MuxHomeRuntime extends LocalRuntime {
@@ -249,15 +265,7 @@ describe("agentSkillsService", () => {
 
     // Should include project/global skills plus built-in skills
     // Note: deep-review skill is a project skill in the Mux repo, not a built-in
-    expect(skills.map((s) => s.name)).toEqual([
-      "bar",
-      "foo",
-      "imagegen",
-      "init",
-      "mux-diagram",
-      "mux-docs",
-      "orchestrate",
-    ]);
+    expect(skills.map((s) => s.name)).toEqual(["bar", "foo", ...BUILT_IN_SKILL_NAMES]);
 
     const foo = skills.find((s) => s.name === "foo");
     expect(foo).toBeDefined();
@@ -657,14 +665,7 @@ describe("agentSkillsService", () => {
 
     const diagnostics = await discoverAgentSkillsDiagnostics(runtime, project.path, { roots });
 
-    expect(diagnostics.skills.map((s) => s.name)).toEqual([
-      "foo",
-      "imagegen",
-      "init",
-      "mux-diagram",
-      "mux-docs",
-      "orchestrate",
-    ]);
+    expect(diagnostics.skills.map((s) => s.name)).toEqual(["foo", ...BUILT_IN_SKILL_NAMES]);
 
     const invalidNames = diagnostics.invalidSkills.map((issue) => issue.directoryName).sort();
     expect(invalidNames).toEqual(
diff --git a/src/node/services/agentStatusService.ts b/src/node/services/agentStatusService.ts
index 45e9afce95..7282caf48f 100644
--- a/src/node/services/agentStatusService.ts
+++ b/src/node/services/agentStatusService.ts
@@ -513,6 +513,21 @@ function extractMessageText(message: MuxMessage): string {
     .join("\n");
 }
 
+/**
+ * Lifecycle phase the status model sees for each AI SDK v5 tool-part `state`.
+ * This is the single highest-signal datum for distinguishing "Deploying
+ * service" (in flight) from "Deployed service" (finished) — without it the
+ * prompt was forced to guess from prose alone. States not listed here
+ * (e.g. `input-streaming`) intentionally yield no phase suffix so the
+ * model isn't asked to interpret transient pre-call states.
+ */
+const TOOL_PART_PHASE_BY_STATE: Record<string, "running" | "done"> = {
+  "input-available": "running",
+  "output-available": "done",
+  // Output returned but body stripped (still "done" for our purposes).
+  "output-redacted": "done",
+};
+
 function summarizeToolPart(part: unknown): string | null {
   if (typeof part !== "object" || part === null) return null;
   const record = part as { type?: unknown; toolName?: unknown; state?: unknown };
@@ -526,20 +541,8 @@ function summarizeToolPart(part: unknown): string | null {
         ? type.slice(5)
         : null;
   if (!toolName) return null;
-  // The lifecycle phase is the single highest-signal datum the status model
-  // needs to distinguish "Deploying service" (in flight) from "Deployed
-  // service" (finished). AI SDK v5 tool parts carry a `state` field:
-  //   - "input-available"  → call sent, no result yet (running)
-  //   - "output-available" → result returned (done)
-  //   - "output-redacted"  → result returned but body stripped (still done)
-  // Without this marker the prompt was forced to guess from prose alone.
   const state = typeof record.state === "string" ? record.state : null;
-  const phase =
-    state === "output-available" || state === "output-redacted"
-      ? "done"
-      : state === "input-available"
-        ? "running"
-        : null;
+  const phase = state !== null ? (TOOL_PART_PHASE_BY_STATE[state] ?? null) : null;
   return phase ? `[tool ${toolName} ${phase}]` : `[tool ${toolName}]`;
 }
 
diff --git a/src/node/services/historyService.ts b/src/node/services/historyService.ts
index f8843ae093..e773f3242c 100644
--- a/src/node/services/historyService.ts
+++ b/src/node/services/historyService.ts
@@ -10,7 +10,7 @@ import {
   type MuxMetadata,
 } from "@/common/types/message";
 import type { Config } from "@/node/config";
-import { ensurePrivateDir } from "@/node/utils/fs";
+import { ensurePrivateDir, isErrnoWithCode } from "@/node/utils/fs";
 import { workspaceFileLocks } from "@/node/utils/concurrency/workspaceFileLocks";
 import { log } from "./log";
 import { getTokenizerForModel } from "@/node/utils/main/tokenizer";
@@ -410,7 +410,7 @@ export class HistoryService {
 
       return messages;
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      if (isErrnoWithCode(error, "ENOENT")) {
         return []; // No history yet
       }
       throw error; // Re-throw non-ENOENT errors
@@ -438,7 +438,7 @@ export class HistoryService {
       const stat = await fs.stat(filePath);
       fileSize = stat.size;
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      if (isErrnoWithCode(error, "ENOENT")) {
         return; // No history
       }
       throw error;
@@ -532,7 +532,7 @@ export class HistoryService {
       const stat = await fs.stat(filePath);
       fileSize = stat.size;
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      if (isErrnoWithCode(error, "ENOENT")) {
         return; // No history
       }
       throw error;
@@ -862,7 +862,7 @@ export class HistoryService {
       const message = JSON.parse(data) as MuxMessage;
       return normalizeLegacyMuxMetadata(message);
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      if (isErrnoWithCode(error, "ENOENT")) {
         return null;
       }
 
@@ -910,7 +910,7 @@ export class HistoryService {
         await fs.unlink(partialPath);
         return Ok(undefined);
       } catch (error) {
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        if (isErrnoWithCode(error, "ENOENT")) {
           return Ok(undefined);
         }
         const errorMessage = getErrorMessage(error);
@@ -939,7 +939,7 @@ export class HistoryService {
         await fs.unlink(partialPath);
         return Ok(true);
       } catch (error) {
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        if (isErrnoWithCode(error, "ENOENT")) {
           return Ok(false);
         }
         const errorMessage = getErrorMessage(error);
@@ -1414,9 +1414,7 @@ export class HistoryService {
             await fs.unlink(historyPath);
           } catch (error) {
             // Ignore ENOENT - file already deleted
-            if (
-              !(error && typeof error === "object" && "code" in error && error.code === "ENOENT")
-            ) {
+            if (!isErrnoWithCode(error, "ENOENT")) {
               throw error;
             }
           }
@@ -1465,9 +1463,7 @@ export class HistoryService {
             await fs.unlink(historyPath);
           } catch (error) {
             // Ignore ENOENT
-            if (
-              !(error && typeof error === "object" && "code" in error && error.code === "ENOENT")
-            ) {
+            if (!isErrnoWithCode(error, "ENOENT")) {
               throw error;
             }
           }
diff --git a/src/node/services/mdnsAdvertiserService.ts b/src/node/services/mdnsAdvertiserService.ts
index 3dd4b188d5..7fd37df4b3 100644
--- a/src/node/services/mdnsAdvertiserService.ts
+++ b/src/node/services/mdnsAdvertiserService.ts
@@ -17,6 +17,23 @@ export const MUX_MDNS_SERVICE_TYPE = "mux-api";
 
 type NetworkInterfaces = NodeJS.Dict<os.NetworkInterfaceInfo[]>;
 
+/**
+ * True when `address` is a link-local address of the given family. Link-local
+ * addresses are filtered out of LAN/discovery/bind-host listings because they
+ * are rarely what users want to connect to or copy/paste.
+ *
+ * Exported so other network-facing services (e.g. `serverService`) can share
+ * the same predicate instead of re-encoding the IPv4 169.254/16 and IPv6
+ * fe80::/10 checks inline.
+ */
+export function isLinkLocalAddress(address: string, family: "IPv4" | "IPv6"): boolean {
+  if (family === "IPv4") {
+    return address.startsWith("169.254.");
+  }
+
+  return address.toLowerCase().startsWith("fe80:");
+}
+
 function getNonInternalInterfaceNames(
   networkInterfaces: NetworkInterfaces,
   family?: "IPv4" | "IPv6"
@@ -37,13 +54,7 @@ function getNonInternalInterfaceNames(
         continue;
       }
 
-      const address = info.address;
-
-      // Filter out link-local addresses (they are rarely what users want to connect to).
-      if (infoFamily === "IPv4" && address.startsWith("169.254.")) {
-        continue;
-      }
-      if (infoFamily === "IPv6" && address.toLowerCase().startsWith("fe80:")) {
+      if (isLinkLocalAddress(info.address, infoFamily)) {
         continue;
       }
 
diff --git a/src/node/services/messageQueue.ts b/src/node/services/messageQueue.ts
index b9c9c30a44..9098ce2553 100644
--- a/src/node/services/messageQueue.ts
+++ b/src/node/services/messageQueue.ts
@@ -1,6 +1,14 @@
-import type { FilePart, SendMessageOptions } from "@/common/orpc/types";
+import type { FilePart, GoalInterventionPolicy, SendMessageOptions } from "@/common/orpc/types";
 import type { ReviewNoteData } from "@/common/types/review";
 
+// Shared object-shape narrowing so the metadata type guards below don't each
+// re-inline the same `typeof === "object" && !== null` check plus a manual
+// `as Record<string, unknown>` cast. Mirrors the local `isRecord` helper used
+// across many other modules in the codebase.
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
 // Type guard for compaction request metadata (for display text)
 interface CompactionMetadata {
   type: "compaction-request";
@@ -16,19 +24,18 @@ interface AgentSkillMetadata {
 }
 
 function isAgentSkillMetadata(meta: unknown): meta is AgentSkillMetadata {
-  if (typeof meta !== "object" || meta === null) return false;
-  const obj = meta as Record<string, unknown>;
-  if (obj.type !== "agent-skill") return false;
-  if (typeof obj.rawCommand !== "string") return false;
-  if (typeof obj.skillName !== "string") return false;
-  if (obj.scope !== "project" && obj.scope !== "global" && obj.scope !== "built-in") return false;
+  if (!isRecord(meta)) return false;
+  if (meta.type !== "agent-skill") return false;
+  if (typeof meta.rawCommand !== "string") return false;
+  if (typeof meta.skillName !== "string") return false;
+  if (meta.scope !== "project" && meta.scope !== "global" && meta.scope !== "built-in")
+    return false;
   return true;
 }
 
 function isCompactionMetadata(meta: unknown): meta is CompactionMetadata {
-  if (typeof meta !== "object" || meta === null) return false;
-  const obj = meta as Record<string, unknown>;
-  return obj.type === "compaction-request" && typeof obj.rawCommand === "string";
+  if (!isRecord(meta)) return false;
+  return meta.type === "compaction-request" && typeof meta.rawCommand === "string";
 }
 
 // Type guard for metadata with reviews
@@ -37,14 +44,14 @@ interface MetadataWithReviews {
 }
 
 function hasReviews(meta: unknown): meta is MetadataWithReviews {
-  if (typeof meta !== "object" || meta === null) return false;
-  const obj = meta as Record<string, unknown>;
-  return Array.isArray(obj.reviews);
+  if (!isRecord(meta)) return false;
+  return Array.isArray(meta.reviews);
 }
 
-type GoalInterventionPolicy = NonNullable<SendMessageOptions["goalInterventionPolicy"]>;
-
 // Derive from the Zod schema (SendMessageOptions) to stay in sync automatically.
+// `GoalInterventionPolicy` lives in `@/common/orpc/types` next to
+// `SendMessageOptions` so the ChatInput + AgentSession callsites share the
+// same alias instead of each privately re-deriving it.
 type QueueDispatchMode = NonNullable<SendMessageOptions["queueDispatchMode"]>;
 
 /**
diff --git a/src/node/services/providerModelFactory.ts b/src/node/services/providerModelFactory.ts
index 2e7a1be592..1264b7f3fc 100644
--- a/src/node/services/providerModelFactory.ts
+++ b/src/node/services/providerModelFactory.ts
@@ -885,6 +885,22 @@ const CODEX_ALLOWED_PARAMS = new Set([
   "text", // structured output via Output.object -> text.format
 ]);
 
+// OpenRouter routing options that need to be nested under "provider" in API request
+// See: https://openrouter.ai/docs/features/provider-routing
+//
+// Hoisted to module scope so we don't reallocate the lookup set on every
+// `createModel` call — the contents are static and shared across all callers.
+const OPENROUTER_ROUTING_OPTIONS = new Set([
+  "order",
+  "allow_fallbacks",
+  "only",
+  "ignore",
+  "require_parameters",
+  "data_collection",
+  "sort",
+  "quantizations",
+]);
+
 // ---------------------------------------------------------------------------
 // Fetch input helpers
 // ---------------------------------------------------------------------------
@@ -1828,25 +1844,12 @@ export class ProviderModelFactory {
           ...extraOptions
         } = providerConfig;
 
-        // OpenRouter routing options that need to be nested under "provider" in API request
-        // See: https://openrouter.ai/docs/features/provider-routing
-        const OPENROUTER_ROUTING_OPTIONS = [
-          "order",
-          "allow_fallbacks",
-          "only",
-          "ignore",
-          "require_parameters",
-          "data_collection",
-          "sort",
-          "quantizations",
-        ];
-
         // Build extraBody: routing options go under "provider", others stay at root
         const routingOptions: Record<string, unknown> = {};
         const otherOptions: Record<string, unknown> = {};
 
         for (const [key, value] of Object.entries(extraOptions)) {
-          if (OPENROUTER_ROUTING_OPTIONS.includes(key)) {
+          if (OPENROUTER_ROUTING_OPTIONS.has(key)) {
             routingOptions[key] = value;
           } else {
             otherOptions[key] = value;
diff --git a/src/node/services/serverService.ts b/src/node/services/serverService.ts
index fc63cc088c..4516276c51 100644
--- a/src/node/services/serverService.ts
+++ b/src/node/services/serverService.ts
@@ -6,7 +6,11 @@ import * as path from "path";
 import { log } from "./log";
 import * as os from "os";
 import { VERSION } from "@/version";
-import { buildMuxMdnsServiceOptions, MdnsAdvertiserService } from "./mdnsAdvertiserService";
+import {
+  buildMuxMdnsServiceOptions,
+  isLinkLocalAddress,
+  MdnsAdvertiserService,
+} from "./mdnsAdvertiserService";
 import type { AppRouter } from "@/node/orpc/router";
 
 export interface ServerInfo {
@@ -110,10 +114,7 @@ function getNonInternalInterfaceAddresses(
       const address = info.address;
 
       // Filter out link-local addresses (they are rarely what users want to copy/paste).
-      if (family === "IPv4" && address.startsWith("169.254.")) {
-        continue;
-      }
-      if (family === "IPv6" && address.toLowerCase().startsWith("fe80:")) {
+      if (isLinkLocalAddress(address, family)) {
         continue;
       }
 
diff --git a/src/node/services/sessionUsageService.ts b/src/node/services/sessionUsageService.ts
index 8b31a86b74..d9d4951c54 100644
--- a/src/node/services/sessionUsageService.ts
+++ b/src/node/services/sessionUsageService.ts
@@ -5,6 +5,7 @@ import assert from "@/common/utils/assert";
 import type { Config } from "@/node/config";
 import type { HistoryService } from "./historyService";
 import { workspaceFileLocks } from "@/node/utils/concurrency/workspaceFileLocks";
+import { isErrnoWithCode } from "@/node/utils/fs";
 import type { ChatUsageDisplay } from "@/common/utils/tokens/usageAggregator";
 import { sumUsageHistory } from "@/common/utils/tokens/usageAggregator";
 import { createDisplayUsage } from "@/common/utils/tokens/displayUsage";
@@ -125,7 +126,7 @@ export class SessionUsageService {
       const data = await fs.readFile(this.getFilePath(workspaceId), "utf-8");
       return JSON.parse(data) as SessionUsageFile;
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      if (isErrnoWithCode(error, "ENOENT")) {
         return this.createEmptyUsageFile();
       }
       throw error;
@@ -346,7 +347,7 @@ export class SessionUsageService {
         return JSON.parse(data) as SessionUsageFile;
       } catch (error) {
         // File missing or corrupted - try to rebuild from messages
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        if (isErrnoWithCode(error, "ENOENT")) {
           const messages = await this.collectFullHistory(workspaceId);
           if (messages.length > 0) {
             await this.rebuildFromMessagesInternal(workspaceId, messages);
@@ -517,7 +518,7 @@ export class SessionUsageService {
       try {
         await fs.unlink(this.getFilePath(workspaceId));
       } catch (error) {
-        if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+        if (!isErrnoWithCode(error, "ENOENT")) {
           throw error;
         }
       }
diff --git a/src/node/services/signingService.test.ts b/src/node/services/signingService.test.ts
index 14903e4a01..11b765d1f8 100644
--- a/src/node/services/signingService.test.ts
+++ b/src/node/services/signingService.test.ts
@@ -27,6 +27,19 @@ function startSshAgent(): { sshAuthSock: string; sshAgentPid: string } {
   return { sshAuthSock: sockMatch[1], sshAgentPid: pidMatch[1] };
 }
 
+/**
+ * Restore (or delete) a process.env entry to a previously-captured value.
+ * Mirrors the original "if saved was undefined, delete; else assign" semantics
+ * so the env is left exactly as it was before the test mutated it.
+ */
+function restoreEnvVar(key: string, savedValue: string | undefined): void {
+  if (savedValue === undefined) {
+    delete process.env[key];
+  } else {
+    process.env[key] = savedValue;
+  }
+}
+
 /** Run test body with SSH_AUTH_SOCK cleared to ensure disk keys are used */
 async function withoutSshAgent<T>(fn: () => Promise<T>): Promise<T> {
   const savedSock = process.env.SSH_AUTH_SOCK;
@@ -38,17 +51,8 @@ async function withoutSshAgent<T>(fn: () => Promise<T>): Promise<T> {
   try {
     return await fn();
   } finally {
-    if (savedSock === undefined) {
-      delete process.env.SSH_AUTH_SOCK;
-    } else {
-      process.env.SSH_AUTH_SOCK = savedSock;
-    }
-
-    if (savedPid === undefined) {
-      delete process.env.SSH_AGENT_PID;
-    } else {
-      process.env.SSH_AGENT_PID = savedPid;
-    }
+    restoreEnvVar("SSH_AUTH_SOCK", savedSock);
+    restoreEnvVar("SSH_AGENT_PID", savedPid);
   }
 }
 
@@ -83,17 +87,8 @@ describe("SigningService", () => {
   afterAll(() => {
     rmSync(testDir, { recursive: true, force: true });
 
-    if (prevEnv.SSH_AUTH_SOCK === undefined) {
-      delete process.env.SSH_AUTH_SOCK;
-    } else {
-      process.env.SSH_AUTH_SOCK = prevEnv.SSH_AUTH_SOCK;
-    }
-
-    if (prevEnv.SSH_AGENT_PID === undefined) {
-      delete process.env.SSH_AGENT_PID;
-    } else {
-      process.env.SSH_AGENT_PID = prevEnv.SSH_AGENT_PID;
-    }
+    restoreEnvVar("SSH_AUTH_SOCK", prevEnv.SSH_AUTH_SOCK);
+    restoreEnvVar("SSH_AGENT_PID", prevEnv.SSH_AGENT_PID);
   });
 
   describe("with Ed25519 key", () => {
diff --git a/src/node/services/streamManager.ts b/src/node/services/streamManager.ts
index aca475533b..d314515fd4 100644
--- a/src/node/services/streamManager.ts
+++ b/src/node/services/streamManager.ts
@@ -64,7 +64,7 @@ import { runLanguageModelCleanup } from "./languageModelCleanup";
 import { shellQuote } from "@/common/utils/shell";
 import { classify429Capacity } from "@/common/utils/errors/classify429Capacity";
 import { normalizeLiteralRequiredToolPattern } from "@/common/utils/agentTools";
-import { extractChunkDeltaText } from "@/common/utils/ai/streamChunks";
+import { extractChunkDeltaText, TEXT_OUTPUT_DELTA_FIELDS } from "@/common/utils/ai/streamChunks";
 
 // Disable noisy AI SDK warning logging.
 globalThis.AI_SDK_LOG_WARNINGS = false;
@@ -546,9 +546,7 @@ export class StreamManager extends EventEmitter {
     streamInfo.partialWritePromise = (async () => {
       try {
         const canonicalModel = normalizeToCanonical(streamInfo.model);
-        const routedThroughGateway =
-          streamInfo.initialMetadata?.routedThroughGateway ??
-          streamInfo.model.startsWith("mux-gateway:");
+        const routedThroughGateway = this.resolveRoutedThroughGateway(streamInfo);
 
         const partialMessage: MuxMessage = {
           id: streamInfo.messageId,
@@ -1665,6 +1663,21 @@ export class StreamManager extends EventEmitter {
     return rawMode === "plan" || rawMode === "exec" ? rawMode : undefined;
   }
 
+  /**
+   * Resolves whether this stream was routed through the mux gateway.
+   *
+   * Prefers the explicit flag recorded in the stream's initial metadata and
+   * falls back to the `mux-gateway:` model-id prefix. Every partial/stream
+   * event write needs this value, so it lives in one place to keep the
+   * metadata-first fallback consistent across callsites.
+   */
+  private resolveRoutedThroughGateway(streamInfo: WorkspaceStreamInfo): boolean {
+    return (
+      streamInfo.initialMetadata?.routedThroughGateway ??
+      streamInfo.model.startsWith("mux-gateway:")
+    );
+  }
+
   private emitStreamStart(
     workspaceId: WorkspaceId,
     streamInfo: WorkspaceStreamInfo,
@@ -1674,9 +1687,7 @@ export class StreamManager extends EventEmitter {
     const streamStartAgentId = streamInfo.initialMetadata?.agentId;
     const streamStartMode = this.getStreamMode(streamInfo.initialMetadata);
     const canonicalModel = normalizeToCanonical(streamInfo.model);
-    const routedThroughGateway =
-      streamInfo.initialMetadata?.routedThroughGateway ??
-      streamInfo.model.startsWith("mux-gateway:");
+    const routedThroughGateway = this.resolveRoutedThroughGateway(streamInfo);
     const routeProvider = streamInfo.initialMetadata?.routeProvider;
 
     this.emit("stream-start", {
@@ -1837,11 +1848,7 @@ export class StreamManager extends EventEmitter {
                 // Providers/SDKs may stream text deltas under different keys.
                 const textDeltaPart = part as Record<string, unknown>;
 
-                const deltaText = extractChunkDeltaText(textDeltaPart, [
-                  "text",
-                  "delta",
-                  "textDelta",
-                ]);
+                const deltaText = extractChunkDeltaText(textDeltaPart, TEXT_OUTPUT_DELTA_FIELDS);
 
                 if (deltaText.length === 0) {
                   if (
@@ -2196,9 +2203,7 @@ export class StreamManager extends EventEmitter {
               streamInfo.initialMetadata?.costsIncluded
             );
             const canonicalModel = normalizeToCanonical(streamInfo.model);
-            const routedThroughGateway =
-              streamInfo.initialMetadata?.routedThroughGateway ??
-              streamInfo.model.startsWith("mux-gateway:");
+            const routedThroughGateway = this.resolveRoutedThroughGateway(streamInfo);
             const toolModelUsages =
               streamInfo.toolModelUsages.length > 0
                 ? streamInfo.toolModelUsages.map(clonePersistedToolModelUsage)
@@ -2471,9 +2476,7 @@ export class StreamManager extends EventEmitter {
     payload: StreamErrorPayload & { errorType: StreamErrorType }
   ): Promise<void> {
     const canonicalModel = normalizeToCanonical(streamInfo.model);
-    const routedThroughGateway =
-      streamInfo.initialMetadata?.routedThroughGateway ??
-      streamInfo.model.startsWith("mux-gateway:");
+    const routedThroughGateway = this.resolveRoutedThroughGateway(streamInfo);
 
     const errorPartialMessage: MuxMessage = {
       id: payload.messageId,
diff --git a/src/node/services/tools/advisor.ts b/src/node/services/tools/advisor.ts
index 83557ba44f..283e10b8c5 100644
--- a/src/node/services/tools/advisor.ts
+++ b/src/node/services/tools/advisor.ts
@@ -10,7 +10,7 @@ import {
 import type { ModelMessage } from "@/common/types/message";
 import { THINKING_LEVEL_OFF, coerceThinkingLevel } from "@/common/types/thinking";
 import { buildProviderOptions } from "@/common/utils/ai/providerOptions";
-import { extractChunkDeltaText } from "@/common/utils/ai/streamChunks";
+import { extractChunkDeltaText, TEXT_OUTPUT_DELTA_FIELDS } from "@/common/utils/ai/streamChunks";
 import { getErrorMessage } from "@/common/utils/errors";
 import { sanitizeErrorMessageForDisplay } from "@/common/utils/providerOutputSanitization";
 import type { AdvisorOutputEvent, AdvisorPhaseEvent } from "@/common/types/stream";
@@ -102,7 +102,7 @@ function getAdvisorTextDelta(chunk: unknown): string | undefined {
     return undefined;
   }
 
-  const text = extractChunkDeltaText(record, ["text", "delta", "textDelta"]);
+  const text = extractChunkDeltaText(record, TEXT_OUTPUT_DELTA_FIELDS);
   return text.length > 0 ? text : undefined;
 }
 
diff --git a/src/node/services/tools/imageArtifacts.ts b/src/node/services/tools/imageArtifacts.ts
index e712091f83..4492c64dc1 100644
--- a/src/node/services/tools/imageArtifacts.ts
+++ b/src/node/services/tools/imageArtifacts.ts
@@ -23,6 +23,12 @@ const THUMBNAIL_MEDIA_TYPE = "image/webp";
 export const IMAGE_TOOL_PROVIDER_SETUP_HINT =
   "Check OpenAI provider credentials, billing, rate limits, and content policy.";
 
+// Setup hint surfaced when a single image tool call requests more images than
+// the configured `maxImagesPerCall` allows. Shared across `image_generate` and
+// `image_edit` so the guidance stays consistent.
+export const IMAGE_TOOL_EXCESS_COUNT_SETUP_HINT =
+  "Adjust Settings > Experiments > Image Tools or request fewer images.";
+
 type ImageModelOperation = "generation" | "editing";
 type ImageToolName = "image_generate" | "image_edit";
 
diff --git a/src/node/services/tools/image_edit.ts b/src/node/services/tools/image_edit.ts
index cf1f750d48..cfc994f70c 100644
--- a/src/node/services/tools/image_edit.ts
+++ b/src/node/services/tools/image_edit.ts
@@ -19,6 +19,7 @@ import {
   getImageDimensions,
   getImageDimensionsFromMetadata,
   getImageOutputDir,
+  IMAGE_TOOL_EXCESS_COUNT_SETUP_HINT,
   IMAGE_TOOL_PROVIDER_SETUP_HINT,
   processImageArtifacts,
   reportImageToolUsage,
@@ -68,7 +69,7 @@ export const createImageEditTool: ToolFactory = (config) => {
         return {
           success: false,
           error: `Requested ${requestedCount} edited images, but Image Tools is configured for a maximum of ${runtime.maxImagesPerCall}.`,
-          setupHint: "Adjust Settings > Experiments > Image Tools or request fewer images.",
+          setupHint: IMAGE_TOOL_EXCESS_COUNT_SETUP_HINT,
         };
       }
 
diff --git a/src/node/services/tools/image_generate.ts b/src/node/services/tools/image_generate.ts
index 2cc00bd497..3dd20a5152 100644
--- a/src/node/services/tools/image_generate.ts
+++ b/src/node/services/tools/image_generate.ts
@@ -12,6 +12,7 @@ import {
   buildOpenAIImageProviderOptions,
   formatImageModelError,
   getImageOutputDir,
+  IMAGE_TOOL_EXCESS_COUNT_SETUP_HINT,
   IMAGE_TOOL_PROVIDER_SETUP_HINT,
   processImageArtifacts,
   reportImageToolUsage,
@@ -48,7 +49,7 @@ export const createImageGenerateTool: ToolFactory = (config) => {
         return {
           success: false,
           error: `Requested ${requestedCount} images, but Image Tools is configured for a maximum of ${runtime.maxImagesPerCall}.`,
-          setupHint: "Adjust Settings > Experiments > Image Tools or request fewer images.",
+          setupHint: IMAGE_TOOL_EXCESS_COUNT_SETUP_HINT,
         };
       }
 
diff --git a/src/node/services/tools/review_pane.ts b/src/node/services/tools/review_pane.ts
index b1c172d91e..11457a109d 100644
--- a/src/node/services/tools/review_pane.ts
+++ b/src/node/services/tools/review_pane.ts
@@ -109,9 +109,14 @@ export function applyReviewPaneUpdate(
   // Dedup by formatted path:range key, preferring the latest comment when
   // the same region is flagged twice (typical when an agent calls `add`
   // and then re-flags a refined comment).
+  //
+  // The seed loop uses the iteration index directly (instead of
+  // `base.indexOf(h)`) so seeding is O(n) and the position the map stores
+  // is unambiguously the slot we just visited — `indexOf` would have been
+  // O(n²) and only worked correctly when every entry was a unique reference.
   const seen = new Map<string, number>();
-  for (const h of base) {
-    seen.set(formatAssistedFilter(h), base.indexOf(h));
+  for (const [i, h] of base.entries()) {
+    seen.set(formatAssistedFilter(h), i);
   }
   for (const h of parsed) {
     const key = formatAssistedFilter(h);
diff --git a/src/node/services/worktreeArchiveSnapshotService.ts b/src/node/services/worktreeArchiveSnapshotService.ts
index ccfcdbaa7d..bc5fc2d340 100644
--- a/src/node/services/worktreeArchiveSnapshotService.ts
+++ b/src/node/services/worktreeArchiveSnapshotService.ts
@@ -27,6 +27,9 @@ import { isPathInsideDir } from "@/node/utils/pathUtils";
 const SNAPSHOT_VERSION = 1;
 const SNAPSHOT_DIR_NAME = "archive-state";
 const SNAPSHOT_METADATA_FILE_NAME = "metadata.json";
+// Single source of truth for the "workspace missing from config" failure so the
+// message stays consistent across the several snapshot operations that guard on it.
+const WORKSPACE_NOT_FOUND_IN_CONFIG_ERROR = "Workspace not found in config";
 const NOOP_INIT_LOGGER: InitLogger = {
   logStep: () => undefined,
   logStdout: () => undefined,
@@ -105,7 +108,7 @@ export class WorktreeArchiveSnapshotService {
       args.workspaceId
     );
     if (!workspaceEntry) {
-      return Err("Workspace not found in config");
+      return Err(WORKSPACE_NOT_FOUND_IN_CONFIG_ERROR);
     }
 
     const workspaceName = getPersistedWorkspaceName(workspaceEntry.workspace);
@@ -165,7 +168,7 @@ export class WorktreeArchiveSnapshotService {
       args.workspaceId
     );
     if (!workspaceEntry) {
-      return Err("Workspace not found in config");
+      return Err(WORKSPACE_NOT_FOUND_IN_CONFIG_ERROR);
     }
 
     const workspaceName = getPersistedWorkspaceName(workspaceEntry.workspace);
@@ -239,7 +242,7 @@ export class WorktreeArchiveSnapshotService {
       args.workspaceId
     );
     if (!workspaceEntry) {
-      return Err("Workspace not found in config");
+      return Err(WORKSPACE_NOT_FOUND_IN_CONFIG_ERROR);
     }
 
     const workspaceName = getPersistedWorkspaceName(workspaceEntry.workspace);
@@ -424,7 +427,7 @@ export class WorktreeArchiveSnapshotService {
       args.workspaceId
     );
     if (!workspaceEntry) {
-      return Err("Workspace not found in config");
+      return Err(WORKSPACE_NOT_FOUND_IN_CONFIG_ERROR);
     }
 
     const snapshot = workspaceEntry.workspace.worktreeArchiveSnapshot;