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/features/ChatInput/index.tsx b/src/browser/features/ChatInput/index.tsx
index d1772bae2e..f7c909865e 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
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/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/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/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/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/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/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/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/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..d0bf6e2ff8 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;
@@ -4944,7 +4972,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 +4990,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/messageQueue.ts b/src/node/services/messageQueue.ts
index b9c9c30a44..725f1192e4 100644
--- a/src/node/services/messageQueue.ts
+++ b/src/node/services/messageQueue.ts
@@ -1,4 +1,4 @@
-import type { FilePart, SendMessageOptions } from "@/common/orpc/types";
+import type { FilePart, GoalInterventionPolicy, SendMessageOptions } from "@/common/orpc/types";
 import type { ReviewNoteData } from "@/common/types/review";
 
 // Type guard for compaction request metadata (for display text)
@@ -42,9 +42,10 @@ function hasReviews(meta: unknown): meta is MetadataWithReviews {
   return Array.isArray(obj.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/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..4531e2b4e9 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;
@@ -1837,11 +1837,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 (
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);